Fix installStackBindist

Fixes #118

.gitlab-ci.yml

@@ -41,7 +41,7 @@ variables:
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
 
 .linux:armv7:
-  image: "arm32v7/fedora"
+  image: "registry.gitlab.haskell.org/ghc/ci-images/armv7-linux-deb10:$DOCKER_REV"
   tags:
     - armv7-linux
   variables:
@@ -50,7 +50,7 @@ variables:
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
 
 .linux:aarch64:
-  image: "arm64v8/fedora"
+  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
   tags:
     - aarch64-linux
   variables:
@@ -124,14 +124,14 @@ variables:
     - .test_ghcup_version
     - .linux:armv7
   before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
+    - ./.gitlab/before_script/linux/install_deps.sh
 
 .test_ghcup_version:aarch64:
   extends:
     - .test_ghcup_version
     - .linux:aarch64
   before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
+    - ./.gitlab/before_script/linux/install_deps.sh
 
 .test_ghcup_version:darwin:
   extends:
@@ -374,7 +374,7 @@ release:linux:armv7:
     - .linux:armv7
     - .release_ghcup
   before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
+    - ./.gitlab/before_script/linux/install_deps.sh
   variables:
     ARTIFACT: "armv7-linux-ghcup"
     GHC_VERSION: "8.10.4"
@@ -387,7 +387,7 @@ release:linux:aarch64:
     - .linux:aarch64
     - .release_ghcup
   before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
+    - ./.gitlab/before_script/linux/install_deps.sh
   variables:
     ARTIFACT: "aarch64-linux-ghcup"
     GHC_VERSION: "8.10.4"

.gitlab/before_script/linux/install_deps.sh

@@ -7,13 +7,60 @@ set -eux
 mkdir -p "${TMPDIR}"
 
 sudo apt-get update -y
-sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https
 
-curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
-chmod +x ghcup-bin
+case "${ARCH}" in
+	ARM*)
+		case "${ARCH}" in
+			"ARM")
+				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+				cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+				;;
+			"ARM64")
+				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+				cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+				;;
+			*)
+				exit 1 ;;
+		esac
 
-./ghcup-bin upgrade -i -f
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+
+		curl -O "${ghc_url}"
+		tar -xf ghc-*.tar.*
+		cd ghc-${GHC_VERSION}
+		./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+		make install
+		for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+			ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+		done
+		for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+			ln -s ${x##*/} ${x%-${GHC_VERSION}}
+		done
+		cd ..
+		rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+		unset x i
+
+		mkdir cabal-install
+		cd cabal-install
+		curl -O "${cabal_url}"
+		tar -xf cabal-install-*
+		mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+		cd ..
+		rm -rf cabal-install
+
+		;;
+	*) 
+		url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
+
+		curl -sSfL "${url}" > ./ghcup-bin
+		chmod +x ghcup-bin
+
+		./ghcup-bin upgrade -i -f
+		./ghcup-bin install ${GHC_VERSION}
+		./ghcup-bin set ${GHC_VERSION}
+		./ghcup-bin install-cabal ${CABAL_VERSION}
+
+		;;
+esac
 

.gitlab/before_script/linux/install_deps_manual.sh

@@ -1,64 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
-
-mkdir -p "${TMPDIR}"
-
-ednf() {
-	case "${ARCH}" in
-		"ARM")
-			sudo dnf -y --forcearch armv7hl "$@"
-			;;
-		"ARM64")
-			sudo dnf -y --forcearch aarch64 "$@"
-			;;
-		*) exit 1 ;;
-	esac
-}
-
-ednf update
-ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel lbzip2 lbzip2-utils bzip2-devel
-if [ "${ARCH}" = "ARM64" ] ; then
-	ednf install numactl numactl-libs numactl-devel
-fi
-ednf install bash wget curl git tar
-ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
-
-case "${ARCH}" in
-	"ARM")
-		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
-		cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
-		;;
-	"ARM64")
-		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
-		cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
-		;;
-	*) exit 1 ;;
-esac
-
-mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-
-curl -O "${ghc_url}"
-tar -xf ghc-*.tar.*
-cd ghc-${GHC_VERSION}
-./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
-make install
-for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
-	ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
-done
-for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
-	ln -s ${x##*/} ${x%-${GHC_VERSION}}
-done
-cd ..
-rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
-unset x i
-
-mkdir cabal-install
-cd cabal-install
-curl -O "${cabal_url}"
-tar -xf cabal-install-*
-mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
-cd ..
-rm -rf cabal-install

.gitlab/ghcup_env

@@ -4,6 +4,6 @@ if [ "${OS}" = "WINDOWS" ] ; then
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 else
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
+	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 fi

.gitlab/script/ghcup_version.sh

@@ -84,8 +84,10 @@ ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
 eghcup --numeric-version
 
 eghcup install ${GHC_VERSION}
+[ `$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version` = "${GHC_VERSION}" ]
 eghcup set ${GHC_VERSION}
 eghcup install-cabal ${CABAL_VERSION}
+[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
 
 cabal --version
 
@@ -125,10 +127,10 @@ else
 
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
-		haskell-language-server-wrapper --version
+		$(eghcup whereis hls) --version
 
 		eghcup install stack
-		stack --version
+		$(eghcup whereis stack) --version
 	elif [ "${OS}" = "LINUX" ] ; then
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls

app/ghcup/Main.hs

@@ -100,6 +100,7 @@ data Command
   | Rm (Either RmCommand RmOptions)
   | DInfo
   | Compile CompileCommand
+  | Whereis WhereisOptions WhereisCommand
   | Upgrade UpgradeOpts Bool
   | ToolRequirements
   | ChangeLog ChangeLogOptions
@@ -190,6 +191,13 @@ data ChangeLogOptions = ChangeLogOptions
   }
 
 
+data WhereisCommand = WhereisTool Tool (Maybe ToolVersion)
+
+data WhereisOptions = WhereisOptions {
+   directory :: Bool
+}
+
+
 -- https://github.com/pcapriotti/optparse-applicative/issues/148
 
 -- | A switch that can be enabled using --foo and disabled using --no-foo.
@@ -335,6 +343,17 @@ com =
            <$> info (compileP <**> helper)
                     (progDesc "Compile a tool from source")
            )
+      <> command
+           "whereis"
+            (info
+             (   (Whereis
+                     <$> (WhereisOptions <$> switch (short 'd' <> long "directory" <> help "return directory of the binary instead of the binary location"))
+                     <*> whereisP
+                 ) <**> helper
+             )
+             (progDesc "Find a tools location"
+             <> footerDoc ( Just $ text whereisFooter ))
+           )
       <> commandGroup "Main commands:"
       )
     <|> subparser
@@ -402,6 +421,23 @@ com =
   By default returns the URI of the ChangeLog of the latest GHC release.
   Pass '-o' to automatically open via xdg-open.|]
 
+  whereisFooter :: String
+  whereisFooter = [s|Discussion:
+  Finds the location of a tool. For GHC, this is the ghc binary, that
+  usually resides in a self-contained "~/.ghcup/ghc/<ghcver>" directory.
+  For cabal/stack/hls this the binary usually at "~/.ghcup/bin/<tool>-<ver>".
+
+Examples:
+  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
+  ghcup whereis ghc 8.10.5
+  # outputs ~/.ghcup/ghc/8.10.5/bin/
+  ghcup whereis --directory ghc 8.10.5
+  # outputs ~/.ghcup/bin/cabal-3.4.0.0
+  ghcup whereis cabal 3.4.0.0
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory cabal 3.4.0.0|]
+
+
 installCabalFooter :: String
 installCabalFooter = [s|Discussion:
   Installs the specified cabal-install version (or a recommended default one)
@@ -706,6 +742,86 @@ Examples:
   ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2 -x armv7-unknown-linux-gnueabihf --config $(pwd)/build.mk -- --enable-unregisterised|]
 
 
+whereisP :: Parser WhereisCommand
+whereisP = subparser
+  (  command
+      "ghc"
+      (WhereisTool GHC <$> info
+        ( optional (toolVersionArgument Nothing (Just GHC)) <**> helper )
+        ( progDesc "Get GHC location"
+        <> footerDoc (Just $ text whereisGHCFooter ))
+      )
+      <>
+     command
+      "cabal"
+      (WhereisTool Cabal <$> info
+        ( optional (toolVersionArgument Nothing (Just Cabal)) <**> helper )
+        ( progDesc "Get cabal location"
+        <> footerDoc (Just $ text whereisCabalFooter ))
+      )
+      <>
+     command
+      "hls"
+      (WhereisTool HLS <$> info
+        ( optional (toolVersionArgument Nothing (Just HLS)) <**> helper )
+        ( progDesc "Get HLS location"
+        <> footerDoc (Just $ text whereisHLSFooter ))
+      )
+      <>
+     command
+      "stack"
+      (WhereisTool Stack <$> info
+        ( optional (toolVersionArgument Nothing (Just Stack)) <**> helper )
+        ( progDesc "Get stack location"
+        <> footerDoc (Just $ text whereisStackFooter ))
+      )
+      <>
+     command
+      "ghcup"
+      (WhereisTool GHCup <$> info ( (pure Nothing) <**> helper ) ( progDesc "Get ghcup location" ))
+  )
+ where
+  whereisGHCFooter = [s|Discussion:
+  Finds the location of a GHC executable, which usually resides in
+  a self-contained "~/.ghcup/ghc/<ghcver>" directory.
+
+Examples:
+  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
+  ghcup whereis ghc 8.10.5
+  # outputs ~/.ghcup/ghc/8.10.5/bin/
+  ghcup whereis --directory ghc 8.10.5 |]
+
+  whereisCabalFooter = [s|Discussion:
+  Finds the location of a Cabal executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/cabal-3.4.0.0
+  ghcup whereis cabal 3.4.0.0
+  # outputs ~/.ghcup/bin
+  ghcup whereis --directory cabal 3.4.0.0|]
+
+  whereisHLSFooter = [s|Discussion:
+  Finds the location of a HLS executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/haskell-language-server-wrapper-1.2.0
+  ghcup whereis hls 1.2.0
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory hls 1.2.0|]
+
+  whereisStackFooter = [s|Discussion:
+  Finds the location of a stack executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/stack-2.7.1
+  ghcup whereis stack 2.7.1
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory stack 2.7.1|]
+
+
 ghcCompileOpts :: Parser GHCCompileOptions
 ghcCompileOpts =
   GHCCompileOptions
@@ -1265,6 +1381,17 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 #endif
                       ]
 
+          let
+            runWhereIs =
+              runLogger
+                . flip runReaderT appstate
+                . runE
+                  @'[ NotInstalled
+                    , NoToolVersionSet
+                    , NextVerNotFound
+                    , TagNotFound
+                    ]
+
           let runUpgrade =
                 runLogger
                   . flip runReaderT appstate
@@ -1628,6 +1755,22 @@ Make sure to clean up #{tmpdir} afterwards.|])
                         runLogger $ $(logError) $ T.pack $ prettyShow e
                         pure $ ExitFailure 9
 
+            Whereis WhereisOptions{..} (WhereisTool tool whereVer) ->
+              runWhereIs (do
+                (v, _) <- liftE $ fromVersion whereVer tool
+                loc <- liftE $ whereIsTool tool v
+                if directory
+                then pure $ takeDirectory loc
+                else pure loc
+                )
+                >>= \case
+                      VRight r -> do
+                        putStr r
+                        pure ExitSuccess
+                      VLeft e -> do
+                        runLogger $ $(logError) $ T.pack $ prettyShow e
+                        pure $ ExitFailure 30
+
             Upgrade uOpts force -> do
               target <- case uOpts of
                 UpgradeInplace  -> Just <$> liftIO getExecutablePath

bootstrap-haskell

@@ -201,10 +201,13 @@ download_ghcup() {
 			;;
 	esac
 
-  edo mkdir -p "${GHCUP_DIR}"
+	edo mkdir -p "${GHCUP_DIR}"
+
+	# we may overwrite this in adjust_bashrc
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
 		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF
+
 	# shellcheck disable=SC1090
     edo . "${GHCUP_DIR}"/env
     eghcup upgrade
@@ -238,28 +241,49 @@ adjust_bashrc() {
 
 	warn ""
 	warn "Detected ${MY_SHELL} shell on your system..."
-	warn "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
+	warn "Do you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\"?"
 	warn ""
-	warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+	warn "[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is \"P\")."
 	warn ""
 
 	while true; do
 		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 			read -r next_answer </dev/tty
 		else
-			next_answer="yes"
+			next_answer="prepend"
 		fi
 
+		case $next_answer in
+			[Pp]* | "")
+				cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
+					export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
+					EOF
+				;;
+			[Aa]*)
+				cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
+					export PATH="\$HOME/.cabal/bin:\$PATH:${GHCUP_BIN}"
+					EOF
+				;;
+			*) ;;
+		esac
+
 		case $next_answer in
 			[Nn]*)
 				return ;;
-			[Yy]* | "")
+			[Pp]* | [Aa]* | "")
 				case $MY_SHELL in
 					"") break ;;
 					fish)
-							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
-							sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						mkdir -p "${GHCUP_PROFILE_FILE%/*}"
+						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
+						case $next_answer in
+							[Pp]* | "")
+								echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+								;;
+							[Aa]*)
+								echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin \$PATH $GHCUP_BIN # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+								;;
+						esac
 						break ;;
 					bash)
 						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
@@ -285,7 +309,8 @@ adjust_bashrc() {
 			*)
 				echo "Possible choices are:"
 				echo
-				echo "Y - Yes, update my \"${GHCUP_PROFILE_FILE}\" (default)"
+				echo "P - Yes, prepend to PATH, taking precedence (default)"
+				echo "A - Yes, append to PATH"
 				echo "N - No, don't mess with my configuration"
 				echo
 				echo "Please make your choice and press ENTER."

ghcup-0.0.5.yaml

@@ -2060,8 +2060,8 @@ ghcupDownloads:
         A_ARM64:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r2
-              dlHash: d67702f7c9e3586e85ed7c1bd09b7544da55bd1d3b4a961a07018348f78cf76b
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r1
+              dlHash: d853372440f3d43babbb868fad399811241760f2233829c92403fcbea8c547ec
           Darwin:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-apple-darwin-ghcup-0.1.15.2
@@ -2069,8 +2069,8 @@ ghcupDownloads:
         A_ARM:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2
-              dlHash: 03a4af5ed895ada1dd21f4cc3f64dc9078a5bf4268313021d004c04bea7f9c2e
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2-r1
+              dlHash: f8add9b39e1f7d0f03904dc69a8683259972a4472432c1ade27d918c39a4a874
   HLS:
     1.1.0:
       viTags: []
@@ -2120,8 +2120,17 @@ ghcupDownloads:
         - old
       viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v251
       viPostInstall: &stack-post |
-        Stack manages GHC versions internally by default. In order to make it use ghcup installed GHC versions have a look at the options 'system-ghc', 'compiler-check' and 'compiler': https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
-        Additionally, you should upgrade stack only through ghcup.
+        Stack manages GHC versions internally by default. In order to make it use ghcup installed
+        GHC versions you can run the following commands:
+          stack config set install-ghc false --global
+          stack config set system-ghc  true  --global
+        
+        On windows, you may find the following config options useful too:
+          skip-msys, extra-path, extra-include-dirs, extra-lib-dirs
+
+        Also check out: https://docs.haskellstack.org/en/stable/yaml_configuration
+
+        !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
       viArch:
         A_64:
           Linux_UnknownLinux:

lib/GHCup.hs

@@ -586,7 +586,7 @@ installStackBindist dlinfo ver = do
            , settings
            } <- lift ask
 
-  whenM (lift (hlsInstalled ver))
+  whenM (lift (stackInstalled ver))
     (throwE $ AlreadyInstalled Stack ver)
 
   -- download (or use cached version)
@@ -1880,3 +1880,49 @@ postGHCInstall ver@GHCTargetVersion {..} = do
     $ getMajorMinorV _tvVersion
   forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi _tvTarget)
     >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
+
+
+-- | Reports the binary location of a given tool:
+--
+--   * for GHC, this reports: @~\/.ghcup\/ghc\/\<ver\>\/bin\/ghc@
+--   * for cabal, this reports @~\/.ghcup\/bin\/cabal-\<ver\>@
+--   * for hls, this reports @~\/.ghcup\/bin\/haskell-language-server-wrapper-\<ver\>@
+--   * for stack, this reports @~\/.ghcup\/bin\/stack-\<ver\>@
+--   * for ghcup, this reports the location of the currently running executable
+whereIsTool :: ( MonadReader AppState m
+               , MonadLogger m
+               , MonadThrow m
+               , MonadFail m
+               , MonadIO m
+               , MonadCatch m
+               , MonadMask m
+               , MonadUnliftIO m
+               )
+            => Tool
+            -> GHCTargetVersion
+            -> Excepts '[NotInstalled] m FilePath
+whereIsTool tool ver@GHCTargetVersion {..} = do
+  AppState { dirs } <- lift ask
+
+  case tool of
+    GHC -> do
+      whenM (lift $ fmap not $ ghcInstalled ver)
+        $ throwE (NotInstalled GHC ver)
+      bdir <- lift $ ghcupGHCDir ver
+      pure (bdir </> "bin" </> "ghc" <> exeExt)
+    Cabal -> do
+      whenM (lift $ fmap not $ cabalInstalled _tvVersion)
+        $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing _tvVersion))
+      pure (binDir dirs </> "cabal-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
+    HLS -> do
+      whenM (lift $ fmap not $ hlsInstalled _tvVersion)
+        $ throwE (NotInstalled HLS (GHCTargetVersion Nothing _tvVersion))
+      pure (binDir dirs </> "haskell-language-server-wrapper-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
+
+    Stack -> do
+      whenM (lift $ fmap not $ stackInstalled _tvVersion)
+        $ throwE (NotInstalled Stack (GHCTargetVersion Nothing _tvVersion))
+      pure (binDir dirs </> "stack-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
+    GHCup -> do
+      currentRunningExecPath <- liftIO getExecutablePath
+      liftIO $ canonicalizePath currentRunningExecPath

lib/GHCup/Utils/Logger.hs

@@ -20,6 +20,7 @@ import           GHCup.Utils.String.QQ
 import           Control.Monad
 import           Control.Monad.IO.Class
 import           Control.Monad.Logger
+import           Data.Char               ( ord )
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -43,20 +44,33 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
   mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
   mylogger _ _ level str' = do
     -- color output
+    let style' = case level of
+          LevelDebug   -> style Bold . color Blue
+          LevelInfo    -> style Bold . color Green
+          LevelWarn    -> style Bold . color Yellow
+          LevelError   -> style Bold . color Red
+          LevelOther _ -> id
     let l = case level of
-          LevelDebug   -> toLogStr (style Bold $ color Blue "[ Debug ]")
-          LevelInfo    -> toLogStr (style Bold $ color Green "[ Info  ]")
-          LevelWarn    -> toLogStr (style Bold $ color Yellow "[ Warn  ]")
-          LevelError   -> toLogStr (style Bold $ color Red "[ Error ]")
+          LevelDebug   -> toLogStr (style' "[ Debug ]")
+          LevelInfo    -> toLogStr (style' "[ Info  ]")
+          LevelWarn    -> toLogStr (style' "[ Warn  ]")
+          LevelError   -> toLogStr (style' "[ Error ]")
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
-    let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
+    let strs = fmap toLogStr . B.split (fromIntegral $ ord '\n') . fromLogStr $ str'
+    let out = case strs of
+                [] -> B.empty
+                (x:xs) -> fromLogStr
+                  . foldr (\a b -> a <> toLogStr "\n" <> b) mempty
+                  . ((l <> toLogStr " " <> x) :)
+                  . fmap (\line' -> toLogStr (style' "[ ...   ] ") <> line' )
+                  $ xs
 
     when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
       $ colorOutter out
 
     -- raw output
     let lr = case level of
-          LevelDebug   -> toLogStr "Debug: "
+          LevelDebug   -> toLogStr "Debug:"
           LevelInfo    -> toLogStr "Info:"
           LevelWarn    -> toLogStr "Warn:"
           LevelError   -> toLogStr "Error:"