func Main()

in main.go [283:430]
104 lines of code
30 McCabe index (conditional complexity)

func Main() {
	var err error

	// disable log prefix
	log.SetFlags(0)

	// set default runtime.json
	if os.Getenv("WSK_RUNTIMES_JSON") == "" {
		os.Setenv("WSK_RUNTIMES_JSON", WSK_RUNTIMES_JSON)
		trace("WSK_RUNTIMES_JSON len=", len(WSK_RUNTIMES_JSON))
	}

	// set runtime version as environment variable
	if os.Getenv("OPS_VERSION") != "" {
		OpsVersion = os.Getenv("OPS_VERSION")
	} else {
		OpsVersion = strings.TrimSpace(OpsVersion)
		os.Setenv("OPS_VERSION", OpsVersion)
	}

	// setup OPS_CMD
	// CLI: ops ...
	me := os.Args[0]
	if strings.Contains("ops ops.exe", filepath.Base(me)) {
		_, err = setupCmd(me)
		if err != nil {
			log.Fatalf("cannot setup cmd: %s", err.Error())
		}
	}
	os.Setenv("OPS", me)

	// setup home
	opsHome := os.Getenv("OPS_HOME")
	if opsHome == "" {
		opsHome, err = homedir.Expand("~/.ops")
	}
	if err != nil {
		log.Fatalf("cannot setup home: %s", err.Error())
	}
	os.Setenv("OPS_HOME", opsHome)
	trace("OPS_HOME", opsHome)

	// add ~/.ops/<os>-<arch>/bin to the path at the beginning
	err = setupBinPath()
	if err != nil {
		log.Fatalf("cannot setup PATH: %s", err.Error())
	}

	// ensure there is ~/.ops/tmp
	err = setupTmp()
	if err != nil {
		log.Fatalf("cannot setup OPS_TMP: %s", err.Error())
	}

	//  setup the OPS_PWD variable
	err = setOpsPwdEnv()
	if err != nil {
		log.Fatalf("cannot setup OPS_PWD: %s", err.Error())
	}

	// setup the envvar for the embedded tools
	os.Setenv("OPS_TOOLS", strings.Join(tools.MergeToolsList(mainTools), " "))

	// CLI: ops -v | --version | -h | --help | -reset
	// preliminanre processing not requiring to  downloading anything
	executeToolsNoDownloadAndExit(os.Args)

	// in case args[1] is a wsk wrapper command invoke it and exit
	// CLI: ops action ... (wsk wrapper)
	if len(os.Args) > 1 {
		if expand, ok := IsWskWrapperCommand(os.Args[1]); ok {
			debug("wsk wrapper cmd", expand)
			rest := os.Args[2:]
			debug("extracted args", rest)

			// if "invoke" is in the command, parse all a=b into -p a b
			if (len(expand) > 2 && expand[2] == "invoke") || slices.Contains(rest, "invoke") {
				rest = parseInvokeArgs(rest)
			}

			if err := tools.Wsk(expand, rest...); err != nil {
				log.Fatalf("error: %s", err.Error())
			}
			os.Exit(0)
		}
	}

	// OPS_REPO && OPS_ROOT_PLUGIN
	getOpsRepo()
	setOpsRootPluginEnv()
	// Check if olaris exists. If not, download tasks
	olarisDir, err := getOpsRoot()
	if err != nil {
		olarisDir := joinpath(joinpath(opsHome, getOpsBranch()), "olaris")
		if !isDir(olarisDir) {
			log.Println("Welcome to ops! Setting up...")
			olarisDir, err = pullTasks(true, true)
			if err != nil {
				log.Fatalf("cannot locate or download OPS_ROOT: %s", err.Error())
			}
			// if just updated, do not repeat
			if len(os.Args) > 1 && os.Args[1] == "-update" {
				os.Exit(0)
			}
		} else {
			// check if olaris was recently updated
			checkUpdated(opsHome, 24*time.Hour)
		}
	}
	if err = setOpsOlarisHash(olarisDir); err != nil {
		os.Setenv("OPS_OLARIS", "<local>")
	}

	// set the enviroment variables from the config
	opsRootDir := getRootDirOrExit()
	debug("opsRootDir", opsRootDir)
	err = setAllConfigEnvVars(opsRootDir, opsHome)
	if err != nil {
		log.Fatalf("cannot apply env vars from configs: %s", err.Error())
	}

	// preflight checks - we need at least ssh curl to proceed
	if err := preflightChecks(); err != nil {
		log.Fatalf("failed preflight check: %s", err.Error())
	}

	// first argument with prefix "-" is considered an embedded tool
	// using "-" or "--" or "-task" invokes the embedded task
	// CLI: ops -<tool> (embedded tool)
	args := os.Args
	if len(args) > 1 && len(args[1]) > 0 && args[1][0] == '-' {
		cmd := args[1][1:]
		if cmd == "t" || cmd == "tasks" {
			banner()
			// remove -t to show tasks and continue to execute and list top level tasks
			args = args[1:]
		} else {
			// execute the embeded tool and exit
			fullargs := append([]string{cmd}, args[2:]...)
			exitCode := executeTools(fullargs, opsHome)
			os.Exit(exitCode)
		}
	}

	if err := runOps(opsRootDir, args); err != nil {
		log.Fatalf("task execution error: %s", err.Error())
	}
}