@coalescesoftware/coa 1.0.156 → 1.0.157

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coalescesoftware/coa",
-    "version": "1.0.156",
+    "version": "1.0.157",
     "license": "ISC",
     "author": "Coalesce Automation, Inc.",
     "main": "index.js",

package/src/index.tsx

@@ -0,0 +1,556 @@
+#! /usr/bin/env node 
+/* eslint-disable multiline-comment-style */
+
+import * as Deploy from "./Deploy"
+import * as Plan from "./Plan"
+import * as Refresh from "./Refresh"
+import * as Package from "./Package"
+import * as Shared from "@coalescesoftware/shared"
+import * as CLIProfile from "./CLIProfile"
+import * as RunOutput from './RunOutput'
+import Chalk from "chalk"
+import { Command } from "commander"
+import * as CommonCLI from './CommonCLI'
+import fs from "fs"
+import inquirer from "inquirer"
+
+// setting this needs to be first!
+Shared.Logging.SetHTTPTransportOptions(Shared.Logging.EHttpServices.CLI)
+const LogCLI = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI)
+const LogCLIInternal = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI_INTERNAL)
+
+const ChalkLogger = {
+    error: (message: string) => LogCLI.error(Chalk.redBright(message)),
+    green: (message: string) => LogCLI.info(Chalk.green(message)),
+    white: (message: string) => LogCLI.info(Chalk.whiteBright(message)),
+    blue: (message: string) => LogCLI.info(Chalk.blueBright(message)),
+}
+
+const program = new Command()
+program.version(require("../package.json").version, "-v, --version")
+program.option("-b, --debug", "Output extra debugging", false)
+program.option("--config <coa-config-location>", "coa config file location")
+
+
+const AddOverridesToCommand = (command)=> {
+    Object.keys(CLIProfile.ICLIProfileExample).forEach((key) => {
+        command.option(`--${key} <value>`, CLIProfile.ICLIProfileExample[key], "")
+    })
+    return command
+}
+
+//computeCLIOverrides returns an object that has a value if any of them have been specified at the command line
+//this is used as the final override when getting a CLIConfig
+const ComputeCLIOverrides = (command):Partial<CLIProfile.ICLIProfile> => {
+    let overrides = {}
+    Object.keys(CLIProfile.ICLIProfileExample).forEach((key) => {
+        const source = command.getOptionValueSource(key)
+        if (source == "cli") {
+            overrides[key] = command.getOptionValue(key)
+        }
+        
+    })
+    return overrides
+}
+/**
+ * Default command (i.e., `coa` by itself) routes to help
+ */
+program.command("none", { hidden: true, isDefault: true })
+    .action(() => {
+        program.help()
+    })
+
+
+/**
+ * Plan command is responsible for reading files and creating a Coalesce Deployment Plan
+ */
+AddOverridesToCommand(program.command(Shared.CLIOperations.ECLICommands.Plan))
+    .option("-d, --dir <dir>", "Coalesce pipeline Yaml file path", ".")
+    .option("--out <plan-location>", "Coalesce plan location", "./coa-plan.json")
+    .description("plan a Coalesce deployment")
+    .action((options,cmd) => {
+        const cliOverrides = ComputeCLIOverrides(cmd)
+
+        const optsWithGlobals = cmd.optsWithGlobals()
+        const directoryPath = optsWithGlobals.dir
+        let logContextToUse: Shared.Logging.LogContext
+
+        // try {
+        //     Shared.CLIOperations.VerifyAllPlanItems(config, token)
+        // } catch (error) {
+        //     LogCLI.error(Chalk.redBright(`Error with required option values: ${error}`))
+        //     Shared.CLIOperations.ExitCLISafe(1)
+        // }
+        
+        LogCLI.info(Chalk.whiteBright(`Pipeline: ${Chalk.green("running")}...`))
+        
+        const debugMode = optsWithGlobals.debug
+        if (!debugMode) {
+            Shared.CLIOperations.DisableNonCLIConsoleLogs()
+        }
+
+        let config;        
+        return Promise.resolve().then(()=> {
+            return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+        })
+        .then((configResult: CLIProfile.ICLIConfig) => {
+            config = configResult
+
+            if (config.runtimeParameters) {
+                CommonCLI.ValidateRuntimeParameters(config.runtimeParameters)
+            }
+
+            return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(config.token, undefined)
+        })
+        .then(({ teamInfo, firebase }: Shared.ConnectionOperations.ITeamInfoAndFirebase) => {
+            const firestore = firebase.firestore()
+            Shared.Logging.SetBackendGlobalContext({ userID: teamInfo.fbUserID, orgID: teamInfo.fbTeamID })
+            const teamID =teamInfo.fbTeamID
+            const environmentID = config.runDetails.environmentID
+
+            return Shared.SchedulerOperations.GetRuntimeParametersObjectForRun(
+                firestore, 
+                teamID,
+                environmentID,
+                config.runtimeParameters)
+        })
+        .then((runtimeParametersObject:Shared.Runner.TRunTimeParametersObjectType) => {
+            const envID = config.runDetails.environmentID
+
+            return Plan.CreatePlan(
+                directoryPath,
+                envID,
+                config.token,
+                `Deploy to environment: ${envID}`,
+                JSON.stringify(runtimeParametersObject)
+            )
+        }).then(result => {
+            const { plan, logContext } = result
+            logContextToUse = logContext
+            fs.writeFile(optsWithGlobals.out, JSON.stringify(plan), "utf8", (error) => {
+                if (error) {
+                    LogCLI.errorContext(logContextToUse, Chalk.redBright(`An error occurred while saving plan ${error}`))
+                    
+                    return `Plan incomplete and not saved to local file.`
+                } else {
+                    LogCLI.infoContext(logContextToUse, Chalk.blueBright(`Plan complete and saved to local file: coa-plan.json`))
+                    Shared.CLIOperations.ExitCLISafe(0)
+                }
+            })
+        }).catch(error => {
+            LogCLI.errorContext(logContextToUse, Chalk.redBright(`An error occurred while creating plan ${error}`))
+            Shared.CLIOperations.ExitCLISafe(1)
+        })
+    })
+
+/**
+ * Deploy command is responsible for taking an already generated plan, and executing it
+ */
+AddOverridesToCommand(program.command(Shared.CLIOperations.ECLICommands.Deploy))
+    .option("-p, --plan <plan-location>", "Coalesce plan location", "./coa-plan.json")
+    .option("-o, --out <output json>", "Run Results Output in Json ")
+    .description("run a coalesce deployment plan")
+    .action((options,cmd) => {
+        const cliOverrides = ComputeCLIOverrides(cmd)
+
+        const optsWithGlobals = cmd.optsWithGlobals()
+        const plan = JSON.parse(fs.readFileSync(optsWithGlobals.plan, { encoding: "utf-8" }))
+        // const config = JSON.parse(fs.readFileSync(cmd.config, { encoding: "utf-8" }))
+        // const token = fs.readFileSync(cmd.token, { encoding: "utf-8" })
+
+        // try {
+        //     Shared.CLIOperations.VerifyAllDeployItems(plan, config, token)
+        // } catch (error) {
+        //     LogCLI.error(Chalk.redBright(`Error with required option values: ${error}`))
+        //     Shared.CLIOperations.ExitCLISafe(1)
+        // }
+        
+        const debugMode = optsWithGlobals.debug
+        if (!debugMode) {
+            Shared.CLIOperations.DisableNonCLIConsoleLogs()
+        }
+        
+        let logContextToUse: Shared.Logging.LogContext
+        let runInfo:Shared.Runner.IRunInfo
+
+        let config;        
+        return Promise.resolve().then(()=> {
+            return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+        })
+        .then((configResult: CLIProfile.ICLIConfig) => {
+            config = configResult
+
+            return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(
+                config.token,
+                undefined,
+            )
+        }).then(({ teamInfo }: Shared.ConnectionOperations.ITeamInfoAndFirebase) => {
+            Shared.Logging.SetBackendGlobalContext({ userID: teamInfo.fbUserID, orgID: teamInfo.fbTeamID })
+
+            runInfo = {
+                runType: Shared.Runner.ERunType.deploy,
+                runStatus: Shared.Runner.ERunStatus.running,
+                runDetails: {
+                    environmentID: config.runDetails.environmentID
+                },
+                userCredentials: config.userCredentials,
+                runTimeParameters: plan.runtimeParameters || {},
+            }
+
+            Shared.Common.assert(Shared.Logging.LoggingArea.CLI,
+                !!runInfo, "runinfo must exist to continue")
+            return Deploy.DeployWithCLI(plan, runInfo, config.token)
+                .then((result) => {
+                    const { runCounter, runCompletion, logContext } = result
+                    logContextToUse = logContext ?? {}
+                    LogCLI.infoContext(logContextToUse, Chalk.whiteBright(
+                        `Job ${runCounter}: ${Chalk.green("running")}...`
+                    ))
+
+                    return runCompletion.finally(()=> {
+                        const outputFilePath = optsWithGlobals.out
+                        CommonCLI.FinishWithOutputFile(
+                            logContextToUse,
+                            outputFilePath,
+                            runCounter, 
+                            config.token
+                            )
+                    })
+                })
+                .then(() => {
+                    LogCLI.infoContext(logContextToUse, "Deployment successful!")
+                    Shared.CLIOperations.ExitCLISafe(0)
+                })
+        }).catch(error => {
+            LogCLI.errorContext(logContextToUse, Chalk.redBright(`An error occurred during deployment ${error.toString()}`))
+            Shared.CLIOperations.ExitCLISafe(1)
+        })
+    })
+
+    /**
+     * Refresh command begins a locally executed Coalesce Environment Run 
+     */
+    AddOverridesToCommand(program.command(Shared.CLIOperations.ECLICommands.Refresh))
+        .description("runs a Coalesce pipeline")
+        .option("-o, --out <output json>", "Run Results Output in Json ")
+    .action(( options, command) => {
+        const cliOverrides = ComputeCLIOverrides(command)
+            const optsWithGlobals = command.optsWithGlobals()
+            const debugMode = optsWithGlobals.debug
+            if (!debugMode) {
+                Shared.CLIOperations.DisableNonCLIConsoleLogs()
+            }
+
+
+
+            let logContextToUse
+
+            //TODO: 
+            //FROM MICHAEL:
+            //WHY DO WE HAVE THIS CONFIG? 
+            let runInfo:Shared.Runner.IRunInfo
+            let config;        
+        return Promise.resolve().then(()=> {
+            return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+        })
+        .then((configResult: CLIProfile.ICLIConfig) => {
+            config = configResult
+            return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(config.token, undefined)
+        })
+        .then(({ teamInfo, firebase }) => {
+            const firestore = firebase.firestore()
+            Shared.Logging.SetBackendGlobalContext({ userID: teamInfo.fbUserID, orgID: teamInfo.fbTeamID })
+            const teamID = teamInfo.fbTeamID
+            const environmentID = config.runDetails.environmentID
+            return Shared.SchedulerOperations.GetRuntimeParametersObjectForRun(firestore,
+                teamID, environmentID, config.runtimeParameters)
+        })
+        .then((runtimeParametersObject:Shared.Runner.TRunTimeParametersObjectType) => {
+            runInfo = {
+                runType: Shared.Runner.ERunType.refresh,
+                runStatus: Shared.Runner.ERunStatus.running,
+                runDetails: {
+                    environmentID: config.runDetails.environmentID,
+                    jobID: config.runDetails.jobID,
+                    includeNodesSelector: config.runDetails.includeNodesSelector,
+                    excludeNodesSelector: config.runDetails.excludeNodesSelector
+                },
+                userCredentials:config.userCredentials,
+                runTimeParameters: runtimeParametersObject,
+            }
+
+            Shared.Common.CleanupUndefinedValuesFromObject(runInfo)
+
+            LogCLIInternal.infoContext(logContextToUse, "cliOverrides", cliOverrides)
+            //LogCLIInternal.infoContext(logContextToUse, "got the cli config", config)
+            //LogCLIInternal.infoContext(logContextToUse, "got the run info", config)
+            Shared.Common.assert(Shared.Logging.LoggingArea.CLI,
+                !!runInfo, "runinfo must exist to continue")
+            return Refresh.RefreshWithCLI(config.token, runInfo)
+            .then((result) => {
+                const { runCounter, runCompletion, logContext } = result
+                logContextToUse = logContext ?? {}
+                LogCLI.infoContext(logContextToUse, Chalk.whiteBright(`Refresh run initialized. RunCounter: ${runCounter}`))
+
+                return runCompletion.finally(() => {
+                    const outputFilePath = optsWithGlobals.out
+                    CommonCLI.FinishWithOutputFile(
+                        logContextToUse,
+                        outputFilePath,
+                        runCounter,
+                        config.token
+                    )
+                }).then(() => {
+                    LogCLI.infoContext(logContextToUse, "Refresh successful!")
+                    Shared.CLIOperations.ExitCLISafe(0)
+                })
+            })
+        }).catch(error => {
+            LogCLI.errorContext(logContextToUse, Chalk.redBright("Error during refresh!: "), error)
+            Shared.CLIOperations.ExitCLISafe(1)
+        })
+    })
+
+//////////////////////////////////////
+///// COA PACKAGES
+//////////////////////////////////////
+
+const PackageInit = program.command(Shared.CLIOperations.ECLICommands.Package)
+    .description("experimental feature")
+    // removing description until Lhotse 4.0 release
+    // .description(`\n--------------------------------------\n*** Experimental Feature ***\n--------------------------------------\nImport workspace information (aka Coalesce Package) from other Coalesce repositories into your the environment provided in your COA config, or --environmentID override. 
+    // \nSubcommands:
+    // add <location>        imports data from <location> (either URL with optional #commit, #branch, or file path)
+    // remove <packageID>    removes imported package with <packageID> from your Coalesce project\n--------------------------------------\n`)
+    .option("--list [workspaceID]", "Lists installed package names for default or specified workspace")
+    // .command("none", { hidden: true, isDefault: true }) // removing description until Lhotse 4.0 release
+    .action((opts, cmd) => {
+        const cliOverrides = ComputeCLIOverrides(cmd)
+        const optsWithGlobals = cmd.optsWithGlobals()
+        const list = optsWithGlobals.list
+        const debugMode = optsWithGlobals.debug
+
+        if (!debugMode) {
+            Shared.CLIOperations.DisableNonCLIConsoleLogs()
+        }
+
+        let environmentID
+        
+        if (list) {
+            return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+            .then((configResult: CLIProfile.ICLIConfig) => {
+                // if list is a boolean, then --list had no workspaceID arg, so use workspaceID from coaConfig, else use provided workspaceID
+                environmentID = typeof list === "boolean" ? configResult.runDetails.environmentID : list
+                return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(configResult.token, undefined)
+            })
+            .then((authInfo) => {
+                const packageContext = Package.InitializePackageContext(authInfo, environmentID)
+
+                return Package.GetPackageListMessageCLI(packageContext)
+            })
+            .then((packageListCLI) => {
+                Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).info(Chalk.bgBlueBright(packageListCLI))
+                Shared.CLIOperations.ExitCLISafe(0)
+            })
+            .catch((error) => {
+                Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).error(Chalk.red(`CLI Package listing error`, error))
+                Shared.CLIOperations.ExitCLISafe(1)
+            })
+        } else {
+            program.help()
+        }
+    })
+
+// removing description until Lhotse 4.0 release - also todo: do this better anyway
+// PackageInit.command("none", { hidden: true, isDefault: true })
+//     .action(() => {
+//         PackageInit.help()
+//     })
+
+const throwForbiddenExperimentalError = () => {
+    const errorMessage = ` 403 - Forbidden: You do not have permission to access this experimental feature`
+    throw new Error(errorMessage)
+}
+
+const AddPackage = AddOverridesToCommand(PackageInit.command(`${Shared.CLIOperations.ECLICommands.Add} <location>`))
+    // .description("imports data from <location> (either URL with optional #commit or dir path) to your Coalesce project for given environment ID") // removing description until Lhotse 4.0 release
+    .option("-y", "Auto-confirm all overwrite prompts")
+
+AddPackage
+    .action((location, options, cmd) => {
+        const cliOverrides = ComputeCLIOverrides(cmd)
+        const optsWithGlobals = cmd.optsWithGlobals()
+        const debugMode = optsWithGlobals.debug
+        const packageLocation: string = location
+        const confirmPrompts: boolean = options.y || false
+
+        if (!debugMode) {
+            Shared.CLIOperations.DisableNonCLIConsoleLogs()
+        }
+
+        ChalkLogger.green(`Initializing package installation...`)
+        
+        let loggerContext
+        let token: string
+        let cliConfig: CLIProfile.ICLIConfig
+        let environmentID
+        let packageContext
+        let packageProvider
+
+        return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+            .then((configResult: CLIProfile.ICLIConfig) => {
+                cliConfig = configResult
+                token = cliConfig.token
+                environmentID = cliConfig.runDetails.environmentID
+
+                return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(token, undefined)
+            })
+            .then((authInfo) => {
+                // this feature only available to SuperUsers until Lhotse release
+                if (!authInfo.teamInfo.fbHasSuperUserAccess) {
+                    throwForbiddenExperimentalError()
+                }
+
+                packageContext = Package.InitializePackageContext(authInfo, environmentID)
+                packageProvider = new Package.PackageProvider(packageLocation, loggerContext)
+
+                // need to getWorkspaceDataFS here in order to get package ID from package provider
+                return packageProvider.getWorkspaceDataFS()
+                    .then(() => Shared.Workspaces.getAllWorkspaceDataFromFirebase(authInfo.firebase.firestore(), authInfo.teamInfo.fbTeamID, environmentID))
+                })
+
+            .then(workspaceData => {
+                const isPackageAlreadyInstalled = Package.IsPackageAlreadyInstalled(workspaceData.packages || {}, packageProvider.id)
+
+                const install = () => {
+                    return Package.InstallPackage(packageProvider, packageContext)
+                        .then(() => {
+                            Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).info(Chalk.green(`CLI Package Installation complete`))
+                            Shared.CLIOperations.ExitCLISafe(0)
+                        })
+                } 
+
+                if (isPackageAlreadyInstalled) {
+                    if (confirmPrompts) {
+                        return install()
+                    } else {
+                        const promptData = [
+                            {
+                                name: "confirmOverwrite",
+                                type: "confirm",
+                                message: `Package "${packageProvider.id}" already exists. Continuing with installation will remove any changes you might have made and overwrite the data previously imported from this package. 
+                                \n\nWould you like to continue installation and overwrite any previously installed package data from "${packageProvider.id}"?`,
+                                default: false
+                            },
+                        ]
+
+                        return inquirer.prompt(promptData)
+                            .then(answers => {
+                                const shouldOverwrite = answers.confirmOverwrite
+
+                                if (shouldOverwrite) {
+                                    return install()
+                                } else {
+                                    Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).info(`CLI Package installation aborted`)
+                                    Shared.CLIOperations.ExitCLISafe(0)
+                                }
+                            })
+                    }
+                } else {
+                    return install()
+                }
+            })
+            .catch(error => {
+                if (error.isTtyError) {
+                    // Prompt couldn't be rendered in the current environment
+                    Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).errorContext(loggerContext, Chalk.red(`There was a problem rendering the overwrite confirmation prompt in your environment. \n\n To overwrite package without prompts, add the -y param to the end of the command and try again.`, error))
+                } 
+                Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).errorContext(loggerContext, Chalk.red(`CLI Package Installation error`, error))
+                Shared.CLIOperations.ExitCLISafe(1)
+            })
+    })
+
+const RemovePackage = AddOverridesToCommand(PackageInit.command(`${Shared.CLIOperations.ECLICommands.Remove} <id>`))
+    // .description("removes imported package with <id> from your Coalesce project for given environment ID") // removing description until Lhotse 4.0 release
+    .option("-y", "Auto-confirm all remove prompts")
+
+RemovePackage
+    .action((id: string, options, cmd) => {
+        const cliOverrides = ComputeCLIOverrides(cmd)
+        const optsWithGlobals = cmd.optsWithGlobals()
+        const debugMode = optsWithGlobals.debug
+        const packageID: string = id.toUpperCase()
+        const confirmPrompts: boolean = options.y || false
+
+        if (!debugMode) {
+            Shared.CLIOperations.DisableNonCLIConsoleLogs()
+        }
+
+        ChalkLogger.green(`Initializing package removal...`)
+
+        let loggerContext: Shared.Logging.LogContext
+        let token: string
+        let cliConfig: CLIProfile.ICLIConfig
+        let environmentID: string | number
+        
+        return CLIProfile.GetCLIConfig(cliOverrides, optsWithGlobals.config)
+            .then((configResult: CLIProfile.ICLIConfig) => {
+                cliConfig = configResult
+                token = cliConfig.token
+                environmentID = cliConfig.runDetails.environmentID
+
+                return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(token, undefined)
+            })
+            .then((authInfo) => {
+                // this feature only available to SuperUsers until Lhotse release
+                if (!authInfo.teamInfo.fbHasSuperUserAccess) {
+                    throwForbiddenExperimentalError()
+                }
+
+                const packageContext = Package.InitializePackageContext(authInfo, environmentID as number)
+                const uninstall = () => Package.UninstallPackage(packageID, packageContext)
+                    .then(() => {
+                        ChalkLogger.green("Package removal completed successfully!")
+                        Shared.CLIOperations.ExitCLISafe(0)
+                    })
+
+                if (confirmPrompts) {
+                    return uninstall()
+                } else {
+                    const promptData = [
+                        {
+                            name: "confirmRemove",
+                            type: "confirm",
+                            message: `Removing a package will remove all imported data from that package, including any edits you have made on that imported data. \n\nAre you sure you'd like to remove package "${packageID}"?`,
+                            default: false
+                        },
+                    ]
+                    return inquirer.prompt(promptData)
+                        .then(answers => {
+                            const shouldRemove = answers.confirmRemove
+                            
+                            if (shouldRemove) {
+                                return uninstall()
+                            } else {
+                                Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).info(`CLI Package removal aborted`)
+                                Shared.CLIOperations.ExitCLISafe(0)
+                            }
+                        })
+                }
+            })
+            .catch(error => {
+                if (error.isTtyError) {
+                    // Prompt couldn't be rendered in the current environment
+                    Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).errorContext(loggerContext, Chalk.red(`There was a problem rendering the removal confirmation prompt in your environment. \n\n To remove without prompts, add the -y param to the end of the command and try again.`, error))
+                } 
+                Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI).errorContext(loggerContext, Chalk.red(`CLI Package removal error`, error))
+                Shared.CLIOperations.ExitCLISafe(1)
+            })
+    })
+    
+/**
+ * Put new commands above.
+ * Don't delete the commands below; they're responsible for Commander reading and executing options.
+ */
+program.parse()
+program.opts()