Windows support

Update stack things
Update www
2021-06-05 21:01:01 +02:00 · 2021-05-30 15:17:04 +02:00 · 2021-05-20 19:21:57 +02:00 · 2021-05-19 19:22:51 +02:00 · 2021-05-19 19:19:12 +02:00
35 changed files with 15284 additions and 16779 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -20,6 +20,7 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .alpine:64bit:
  image: "alpine:3.12"
@@ -28,6 +29,7 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .alpine:32bit:
  image: "i386/alpine:3.12"
@@ -36,6 +38,7 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "32"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .linux:armv7:
  image: "arm32v7/fedora"
@@ -44,6 +47,7 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "ARM"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .linux:aarch64:
  image: "arm64v8/fedora"
@@ -52,6 +56,7 @@ variables:
  variables:
    OS: "LINUX"
    ARCH: "ARM64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .darwin:
  tags:
@@ -59,6 +64,7 @@ variables:
  variables:
    OS: "DARWIN"
    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .freebsd:
  tags:
@@ -66,22 +72,25 @@ variables:
  variables:
    OS: "FREEBSD"
    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.windows:
+  tags:
+    - new-x86_64-windows
+  variables:
+    OS: "WINDOWS"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

 .root_cleanup:
  after_script:
-    - BUILD_DIR=$CI_PROJECT_DIR
-    - echo "Cleaning $BUILD_DIR"
-    - cd $HOME
-    - test -n "$BUILD_DIR"
-    - shopt -s extglob
-    - rm -Rf "$BUILD_DIR"/!(out)
-    - exit 0
+    - bash ./.gitlab/after_script.sh

 .test_ghcup_version:
  script:
-    - ./.gitlab/script/ghcup_version.sh
+    - bash ./.gitlab/script/ghcup_version.sh
  variables:
-    JSON_VERSION: "0.0.4"
+    JSON_VERSION: "0.0.5"
  artifacts:
    expire_in: 2 week
    paths:
@@ -132,9 +141,18 @@ variables:
  before_script:
    - ./.gitlab/before_script/freebsd/install_deps.sh

+.test_ghcup_version:windows:
+  extends:
+    - .test_ghcup_version
+    - .windows
+    - .root_cleanup
+  before_script:
+    - set CABAL_DIR="$CI_PROJECT_DIR/cabal"
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+
 .release_ghcup:
  script:
-    - ./.gitlab/script/ghcup_release.sh
+    - bash ./.gitlab/script/ghcup_release.sh
  artifacts:
    expire_in: 2 week
    paths:
@@ -142,7 +160,7 @@ variables:
  only:
    - tags
  variables:
-    JSON_VERSION: "0.0.4"
+    JSON_VERSION: "0.0.5"

 ######## stack test ########

@@ -260,6 +278,15 @@ test:freebsd:latest:
  when: manual
  needs: []

+######## windows test ########
+
+test:windows:recommended:
+  stage: test
+  extends: .test_ghcup_version:windows
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []

 ######## linux release ########

@@ -350,6 +377,21 @@ release:freebsd:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"

+######## windows release ########
+
+release:windows:
+  stage: release
+  needs: ["test:windows:recommended"]
+  extends:
+    - .windows
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-mingw64-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"

 ######## hlint ########

--- a/.gitlab/after_script.sh
+++ b/.gitlab/after_script.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -eux
+
+BUILD_DIR=$CI_PROJECT_DIR
+echo "Cleaning $BUILD_DIR"
+cd $HOME
+test -n "$BUILD_DIR"
+shopt -s extglob
+rm -Rf "$BUILD_DIR"/!(out)
+if [ "${OS}" = "WINDOWS" ] ; then
+	rm -Rf /c/ghcup
+fi
+
+exit 0
--- a/.gitlab/before_script/windows/install_deps.sh
+++ b/.gitlab/before_script/windows/install_deps.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}" "${CABAL_DIR}"
+
+rm -rf /c/ghcup
+mkdir -p /c/ghcup
+
+CI_PROJECT_DIR=$(pwd)
+curl -o ghcup.exe https://downloads.haskell.org/~ghcup/tmp/x86_64-mingw64-ghcup-5.exe
+chmod +x ghcup.exe
+
+./ghcup.exe install ${GHC_VERSION}
+./ghcup.exe set ${GHC_VERSION}
+./ghcup.exe install-cabal ${CABAL_VERSION}
+
+rm ./ghcup.exe
+
+exit 0
--- a/.gitlab/ghcup_env
+++ b/.gitlab/ghcup_env
@@ -1,3 +1,9 @@
-export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
-export TMPDIR="$CI_PROJECT_DIR/tmp"
+if [ "${OS}" = "WINDOWS" ] ; then
+	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+	export PATH="/c/ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
+	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 TMPDIR="$CI_PROJECT_DIR/tmp"
+fi
--- a/.gitlab/script/ghcup_bootstrap.sh
+++ b/.gitlab/script/ghcup_bootstrap.sh
@@ -7,7 +7,7 @@ set -eux
 mkdir -p "$CI_PROJECT_DIR"/.local/bin

 ecabal() {
-	cabal --store-dir="$(pwd)"/.store "$@"
+	cabal "$@"
 }

 eghcup() {
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -7,7 +7,7 @@ set -eux
 mkdir -p "$CI_PROJECT_DIR"/.local/bin

 ecabal() {
-	cabal --store-dir="$(pwd)"/.store "$@"
+	cabal "$@"
 }

 git describe
@@ -30,6 +30,8 @@ if [ "${OS}" = "LINUX" ] ; then
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" -ftui
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static"
 else
 	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
 fi
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -6,12 +6,18 @@ set -eux

 mkdir -p "$CI_PROJECT_DIR"/.local/bin

+CI_PROJECT_DIR=$(pwd)
+
 ecabal() {
-	cabal --store-dir="$CI_PROJECT_DIR"/.store "$@"
+	cabal "$@"
 }

 eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	if [ "${OS}" = "WINDOWS" ] ; then
+		ghcup -v -c -s file:/$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	else
+		ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	fi
 }

 git describe --always
@@ -36,6 +42,9 @@ elif [ "${OS}" = "LINUX" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 	fi
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION}
+	ecabal test -w ghc-${GHC_VERSION} ghcup-test
 else
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@

 ## 0.1.15 -- ????-??-??

+* Add windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130)
 * Add date to GHC bindist names created by ghcup
 * Warn when /tmp doesn't have 5GB or more of disk space
 * Allow to compile GHC from git repo wrt [#126](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/126)
--- a/app/ghcup-gen/Main.hs
+++ b/app/ghcup-gen/Main.hs
@@ -123,8 +123,8 @@ main = do

 where
  valAndExit f contents = do
-    (GHCupInfo _ av) <- case Y.decodeEither' contents of
+    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
      Right r -> pure r
      Left  e -> die (color Red $ show e)
-    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)
+    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
      >>= exitWith
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -11,6 +11,7 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
+import           GHCup.Platform
 import           GHCup.Types
 import           GHCup.Types.Optics
 import           GHCup.Utils
@@ -22,6 +23,7 @@ import qualified Codec.Archive.Tar             as Tar
 #else
 import           Codec.Archive
 #endif
+import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
@@ -66,8 +68,9 @@ addError = do

 validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
         => GHCupDownloads
+         -> M.Map GlobalTool DownloadInfo
         -> m ExitCode
-validate dls = do
+validate dls _ = do
  ref <- liftIO $ newIORef 0

  -- verify binary downloads --
@@ -191,22 +194,24 @@ validateTarballs :: ( Monad m
                    , MonadIO m
                    , MonadUnliftIO m
                    , MonadMask m
+                    , Alternative m
+                    , MonadFail m
                    )
                 => TarballFilter
                 -> GHCupDownloads
+                 -> M.Map GlobalTool DownloadInfo
                 -> m ExitCode
-validateTarballs (TarballFilter tool versionRegex) dls = do
+validateTarballs (TarballFilter tool versionRegex) dls gt = do
  ref <- liftIO $ newIORef 0

  flip runReaderT ref $ do
     -- download/verify all tarballs
-    let dlis = nubOrd $ dls ^.. each
-          %& indices (maybe (const True) (==) tool) %> each
-          %& indices (matchTest versionRegex . T.unpack . prettyVer)
-          % (viSourceDL % _Just `summing` viArch % each % each % each)
+    let dlis = nubOrd $ dls ^.. each %& indices (maybe (const True) (==) tool) %> each %& indices (matchTest versionRegex . T.unpack . prettyVer) % (viSourceDL % _Just `summing` viArch % each % each % each)
    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError

-    forM_ dlis downloadAll
+    let gdlis = nubOrd $ gt ^.. each
+
+    forM_ (dlis ++ gdlis) downloadAll

    -- exit
    e <- liftIO $ readIORef ref
@@ -223,11 +228,21 @@ validateTarballs (TarballFilter tool versionRegex) dls = do
                                     }
  downloadAll dli = do
    dirs <- liftIO getDirs
-    let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
+
+    pfreq <- (
+      runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
+      ) >>= \case
+              VRight r -> pure r
+              VLeft e -> do
+                lift $ runLogger
+                  ($(logError) $ T.pack $ prettyShow e)
+                liftIO $ exitWith (ExitFailure 2)
+
+    let appstate = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq

    r <-
      runLogger
-      . flip runReaderT settings
+      . flip runReaderT appstate
      . runResourceT
      . runE @'[DigestError
               , DownloadFailed
@@ -242,12 +257,11 @@ validateTarballs (TarballFilter tool versionRegex) dls = do
        case tool of
          Just GHCup -> do
            let fn = "ghcup"
-            dir <- liftIO ghcupCacheDir
-            p <- liftE $ download dli dir (Just fn)
-            liftE $ checkDigest dli p
+            p <- liftE $ download (settings appstate) dli (cacheDir dirs) (Just fn)
+            liftE $ checkDigest (settings appstate) dli p
            pure Nothing
          _ -> do
-            p <- liftE $ downloadCached dli Nothing
+            p <- liftE $ downloadCached (settings appstate) dirs dli Nothing
            fmap (Just . head . splitDirectories . head)
              . liftE
              . getArchiveFiles
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -6,6 +6,7 @@
 {-# LANGUAGE TemplateHaskell   #-}
 {-# LANGUAGE TypeApplications  #-}
 {-# LANGUAGE ViewPatterns      #-}
+{-# LANGUAGE RankNTypes        #-}

 module BrickMain where

@@ -32,6 +33,7 @@ import           Codec.Archive
 import           Control.Exception.Safe
 import           Control.Monad.Logger
 import           Control.Monad.Reader
+import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.Resource
 import           Data.Bool
 import           Data.Functor
@@ -58,11 +60,12 @@ import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V


+hiddenTools :: [Tool]
+hiddenTools = [Stack]
+

 data BrickData = BrickData
  { lr    :: [ListResult]
-  , dls   :: GHCupDownloads
-  , pfreq :: PlatformRequest
  }
  deriving Show

@@ -97,7 +100,7 @@ keyHandlers KeyBindings {..} =
  [ (bQuit, const "Quit"     , halt)
  , (bInstall, const "Install"  , withIOAction install')
  , (bUninstall, const "Uninstall", withIOAction del')
-  , (bSet, const "Set"      , withIOAction set')
+  , (bSet, const "Set"      , withIOAction ((liftIO .) . set'))
  , (bChangelog, const "ChangeLog", withIOAction changelog')
  , ( bShowAllVersions
    , \BrickSettings {..} ->
@@ -149,12 +152,7 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
      <+> minHSize 15 (str "Version")
      <+> padLeft (Pad 1) (minHSize 25 $ str "Tags")
      <+> padLeft (Pad 5) (str "Notes")
-  renderList' = withDefAttr listAttr . drawListElements renderItem True . filterStack
-  filterStack appState'
-    | showAllTools as = appState'
-    | let v = clr appState'
-          nv = V.filter (\ListResult{..} -> lTool /= Stack) v
-    , otherwise = BrickInternalState { clr = nv, ix = ix appState' }
+  renderList' = withDefAttr listAttr . drawListElements renderItem True
  renderItem _ b listResult@ListResult{..} =
    let marks = if
          | lSet       -> (withAttr "set" $ str "✔✔")
@@ -329,21 +327,25 @@ moveCursor steps ais@BrickInternalState{..} direction =

 -- | Suspend the current UI and run an IO action in terminal. If the
 -- IO action returns a Left value, then it's thrown as userError.
-withIOAction :: (BrickState -> (Int, ListResult) -> IO (Either String a))
+withIOAction :: (BrickState
+                 -> (Int, ListResult)
+                 -> ReaderT AppState IO (Either String a))
             -> BrickState
             -> EventM n (Next BrickState)
 withIOAction action as = case listSelectedElement' (appState as) of
  Nothing      -> continue as
-  Just (ix, e) -> suspendAndResume $ do
-    action as (ix, e) >>= \case
-      Left  err -> putStrLn ("Error: " <> err)
-      Right _   -> putStrLn "Success"
-    getAppData Nothing (pfreq . appData $ as) >>= \case
-      Right data' -> do
-        putStrLn "Press enter to continue"
-        _ <- getLine
-        pure (updateList data' as)
-      Left err -> throwIO $ userError err
+  Just (ix, e) -> do
+    suspendAndResume $ do
+      settings <- readIORef settings'
+      flip runReaderT settings $ action as (ix, e) >>= \case
+        Left  err -> liftIO $ putStrLn ("Error: " <> err)
+        Right _   -> liftIO $ putStrLn "Success"
+      getAppData Nothing >>= \case
+        Right data' -> do
+          putStrLn "Press enter to continue"
+          _ <- getLine
+          pure (updateList data' as)
+        Left err -> throwIO $ userError err


 -- | Update app data and list internal state based on new evidence.
@@ -364,7 +366,9 @@ constructList :: BrickData
              -> Maybe BrickInternalState
              -> BrickInternalState
 constructList appD appSettings =
-  replaceLR (filterVisible (showAllVersions appSettings)) (lr appD)
+  replaceLR (filterVisible (showAllVersions appSettings)
+                           (showAllTools appSettings))
+            (lr appD)

 listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
 listSelectedElement' BrickInternalState{..} = fmap (ix, ) $ clr !? ix
@@ -397,21 +401,32 @@ replaceLR filterF lr s =
    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2


-filterVisible :: Bool -> ListResult -> Bool
-filterVisible showAllVersions e | lInstalled e = True
-                                | showAllVersions = True
-                                | otherwise    = not (elem Old (lTag e))
+filterVisible :: Bool -> Bool -> ListResult -> Bool
+filterVisible v t e | lInstalled e = True
+                    | v
+                    , not t
+                    , not (elem (lTool e) hiddenTools) = True
+                    | not v
+                    , t
+                    , not (elem Old (lTag e)) = True
+                    | v
+                    , t = True
+                    | otherwise = not (elem Old (lTag e)) &&
+                                  not (elem (lTool e) hiddenTools)


-install' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
+install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+         => BrickState
+         -> (Int, ListResult)
+         -> m (Either String ())
+install' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  l        <- liftIO $ readIORef logger'
  let runLogger = myLoggerT l

  let run =
        runLogger
-          . flip runReaderT settings
          . runResourceT
          . runE
            @'[ AlreadyInstalled
@@ -435,24 +450,24 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
      case lTool of
        GHC   -> do
          let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin dls lVer pfreq $> vi
+          liftE $ installGHCBin lVer $> vi
        Cabal -> do
          let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin dls lVer pfreq $> vi
+          liftE $ installCabalBin lVer $> vi
        GHCup -> do
          let vi = snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
+          liftE $ upgradeGHCup Nothing False $> vi
        HLS   -> do
          let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin dls lVer pfreq $> vi
+          liftE $ installHLSBin lVer $> vi
        Stack -> do
          let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin dls lVer pfreq $> vi
+          liftE $ installStackBin lVer $> vi
    )
    >>= \case
          VRight vi                         -> do
            forM_ (_viPostInstall =<< vi) $ \msg ->
-              runLogger $ $(logInfo) msg
+              myLoggerT l $ $(logInfo) msg
            pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
          VLeft (V NoUpdate) -> pure $ Right ()
@@ -484,13 +499,16 @@ set' _ (_, ListResult {..}) = do
          VLeft  e -> pure $ Left (prettyShow e)


-del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
+del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+del' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask

-  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]
+  l <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+  let run = myLoggerT l . runE @'[NotInstalled]

  run (do
      let vi = getVersionInfo lVer lTool dls
@@ -509,8 +527,12 @@ del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
          VLeft  e -> pure $ Left (prettyShow e)


-changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
+changelog' :: (MonadReader AppState m, MonadIO m)
+           => BrickState
+           -> (Int, ListResult)
+           -> m (Either String ())
+changelog' _ (_, ListResult {..}) = do
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
  case getChangeLog dls lTool (Left lVer) of
    Nothing -> pure $ Left
      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
@@ -539,6 +561,8 @@ settings' = unsafePerformIO $ do
                                })
                      dirs
                      defaultKeyBindings
+                      (GHCupInfo mempty mempty mempty)
+                      (PlatformRequest A_64 Darwin Nothing)



@@ -554,10 +578,9 @@ logger' = unsafePerformIO

 brickMain :: AppState
          -> LoggerConfig
-          -> GHCupDownloads
-          -> PlatformRequest
+          -> GHCupInfo
          -> IO ()
-brickMain s l av pfreq' = do
+brickMain s l gi = do
  writeIORef settings' s
  -- logger interpreter
  writeIORef logger'   l
@@ -565,7 +588,7 @@ brickMain s l av pfreq' = do

  no_color <- isJust <$> lookupEnv "NO_COLOR"

-  eAppData <- getAppData (Just av) pfreq'
+  eAppData <- getAppData (Just gi)
  case eAppData of
    Right ad ->
      defaultMain
@@ -586,8 +609,8 @@ defaultAppSettings :: BrickSettings
 defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = False }


-getDownloads' :: IO (Either String GHCupDownloads)
-getDownloads' = do
+getGHCupInfo :: IO (Either String GHCupInfo)
+getGHCupInfo = do
  settings <- readIORef settings'
  l        <- readIORef logger'
  let runLogger = myLoggerT l
@@ -596,29 +619,25 @@ getDownloads' = do
    runLogger
    . flip runReaderT settings
    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
-    $ fmap _ghcupDownloads
    $ liftE
-    $ getDownloadsF (urlSource . GT.settings $ settings)
+    $ getDownloadsF (GT.settings settings) (GT.dirs settings)

  case r of
    VRight a -> pure $ Right a
    VLeft  e -> pure $ Left (prettyShow e)


-getAppData :: Maybe GHCupDownloads
-           -> PlatformRequest
+getAppData :: Maybe GHCupInfo
           -> IO (Either String BrickData)
-getAppData mg pfreq' = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
+getAppData mgi = runExceptT $ do
+  l        <- liftIO $ readIORef logger'
  let runLogger = myLoggerT l

-  r <- maybe getDownloads' (pure . Right) mg
+  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
+  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
+  settings <- liftIO $ readIORef settings'

  runLogger . flip runReaderT settings $ do
-    case r of
-      Right dls -> do
-        lV <- listVersions dls Nothing Nothing pfreq'
-        pure $ Right $ BrickData (reverse lV) dls pfreq'
-      Left e -> pure $ Left [i|#{e}|]
+    lV <- listVersions Nothing Nothing
+    pure $ BrickData (reverse lV)

--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -79,8 +79,6 @@ import qualified Text.Megaparsec.Char          as MPC



-
-
 data Options = Options
  {
  -- global options
@@ -807,53 +805,47 @@ versionArgument criteria tool = argument (eitherReader tVersionEither) (metavar

 tagCompleter :: Tool -> [String] -> Completer
 tagCompleter tool add = listIOCompleter $ do
+  dirs' <- liftIO getDirs
  let loggerConfig = LoggerConfig
        { lcPrintDebug = False
        , colorOutter  = mempty
        , rawOutter    = mempty
        }
-
-      runLogger = myLoggerT loggerConfig
-
-  dirs <- getDirs
-  let simpleSettings = Settings False False Never Curl False GHCupURL
-      simpleAppState = AppState simpleSettings dirs defaultKeyBindings
-      runEnv = runLogger . flip runReaderT simpleAppState
-
-  mGhcUpInfo <- runEnv . runE $ readFromCache
-
+  let runLogger = myLoggerT loggerConfig
+  mGhcUpInfo <- runLogger . runE $ readFromCache dirs'
  case mGhcUpInfo of
-    VRight dls -> do
+    VRight ghcupInfo -> do
      let allTags = filter (\t -> t /= Old)
            $ join
            $ M.elems
-            $ availableToolVersions (_ghcupDownloads dls) tool
+            $ availableToolVersions (_ghcupDownloads ghcupInfo) tool
      pure $ nub $ (add ++) $ fmap tagToString allTags
    VLeft _ -> pure  (nub $ ["recommended", "latest"] ++ add)


 versionCompleter :: Maybe ListCriteria -> Tool -> Completer
 versionCompleter criteria tool = listIOCompleter $ do
+  dirs' <- liftIO getDirs
  let loggerConfig = LoggerConfig
        { lcPrintDebug = False
        , colorOutter  = mempty
        , rawOutter    = mempty
        }
-
-      runLogger = myLoggerT loggerConfig
-
+  let runLogger = myLoggerT loggerConfig
+  mGhcUpInfo <- runLogger . runE $ readFromCache dirs'
  mpFreq <- runLogger . runE $ platformRequest
+  forFold mpFreq $ \pfreq ->
+    forFold mGhcUpInfo $ \ghcupInfo -> do
+      let appState = AppState
+            (Settings True False Never Curl False GHCupURL)
+            dirs'
+            defaultKeyBindings
+            ghcupInfo
+            pfreq

-  forFold mpFreq $ \pfreq -> do
-    dirs <- getDirs
-    let simpleSettings = Settings False False Never Curl False GHCupURL
-        simpleAppState = AppState simpleSettings dirs defaultKeyBindings
-        runEnv = runLogger . flip runReaderT simpleAppState
+          runEnv = runLogger . flip runReaderT appState

-    mGhcUpInfo <- runEnv . runE $ readFromCache
-
-    forFold mGhcUpInfo $ \(GHCupInfo _ dls) -> do
-      installedVersions <- runEnv $ listVersions dls (Just tool) criteria pfreq
+      installedVersions <- runEnv $ listVersions (Just tool) criteria
      return $ T.unpack . prettyVer . lVer <$> installedVersions


@@ -974,9 +966,8 @@ bindistParser :: String -> Either String URI
 bindistParser = first show . parseURI strictURIParserOptions . UTF8.fromString


-toSettings :: Options -> IO AppState
+toSettings :: Options -> IO (Settings, KeyBindings)
 toSettings options = do
-  dirs <- getDirs
  userConf <- runE @'[ JSONError ] ghcupConfigFile >>= \case
    VRight r -> pure r
    VLeft (V (JSONDecodeError e)) -> do
@@ -984,10 +975,10 @@ toSettings options = do
      pure defaultUserSettings
    _ -> do
      die "Unexpected error!"
-  pure $ mergeConf options dirs userConf
+  pure $ mergeConf options userConf
 where
-   mergeConf :: Options -> Dirs -> UserSettings -> AppState
-   mergeConf Options{..} dirs UserSettings{..} =
+   mergeConf :: Options -> UserSettings -> (Settings, KeyBindings)
+   mergeConf Options{..} UserSettings{..} =
     let cache       = fromMaybe (fromMaybe False uCache) optCache
         noVerify    = fromMaybe (fromMaybe False uNoVerify) optNoVerify
         verbose     = fromMaybe (fromMaybe False uVerbose) optVerbose
@@ -995,7 +986,7 @@ toSettings options = do
         downloader  = fromMaybe (fromMaybe defaultDownloader uDownloader) optsDownloader
         keyBindings = maybe defaultKeyBindings mergeKeys uKeyBindings
         urlSource   = maybe (fromMaybe GHCupURL uUrlSource) OwnSource optUrlSource
-     in AppState (Settings {..}) dirs keyBindings
+     in (Settings {..}, keyBindings)
 #if defined(INTERNAL_DOWNLOADER)
   defaultDownloader = Internal
 #else
@@ -1038,7 +1029,10 @@ upgradeOptsP =
 describe_result :: String
 describe_result = $( LitE . StringL <$>
                     runIO (do
-                             CapturedProcess{..} <- executeOut "git" ["describe"] Nothing
+                             CapturedProcess{..} <-  do
+                              dirs <- liftIO getDirs
+                              let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
+                              flip runReaderT settings $ executeOut "git" ["describe"] Nothing
                             case _exitCode of
                               ExitSuccess   -> pure . T.unpack . decUTF8Safe' $ _stdOut
                               ExitFailure _ -> pure numericVer
@@ -1048,6 +1042,11 @@ describe_result = $( LitE . StringL <$>

 main :: IO ()
 main = do
+  -- https://gitlab.haskell.org/ghc/ghc/issues/8118
+  setLocaleEncoding utf8
+
+  void enableAnsiSupport
+
  let versionHelp = infoOption
        ( ("The GHCup Haskell installer, version " <>)
          (head . lines $ describe_result)
@@ -1084,28 +1083,76 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
            (footerDoc (Just $ text main_footer))
      )
    >>= \opt@Options {..} -> do
-          appstate@AppState{dirs = Dirs{..}, ..} <- toSettings opt
+          dirs <- getDirs
+
+          (settings, keybindings) <- toSettings opt

          -- create ~/.ghcup dir
-          createDirRecursive' baseDir
+          createDirRecursive' (baseDir dirs)

          -- logger interpreter
-          logfile <- flip runReaderT appstate $ initGHCupFileLogging
+          logfile <- initGHCupFileLogging (logsDir dirs)
          let loggerConfig = LoggerConfig
                { lcPrintDebug = verbose settings
                , colorOutter  = B.hPut stderr
                , rawOutter    = B.appendFile logfile
                }
          let runLogger = myLoggerT loggerConfig
+          let siletRunLogger = myLoggerT loggerConfig { colorOutter = \_ -> pure () }
+
+          pfreq <- (
+            runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
+            ) >>= \case
+                    VRight r -> pure r
+                    VLeft e -> do
+                      runLogger
+                        ($(logError) $ T.pack $ prettyShow e)
+                      exitWith (ExitFailure 2)
+
+
+
+          ----------------------------------------
+          -- Getting download and platform info --
+          ----------------------------------------
+          
+          ghcupInfo <-
+            ( runLogger
+              . runE @'[JSONError , DownloadFailed, FileDoesNotExistError]
+              $ liftE
+              $ getDownloadsF settings dirs
+              )
+              >>= \case
+                    VRight r -> pure r
+                    VLeft  e -> do
+                      runLogger
+                        ($(logError) $ T.pack $ prettyShow e)
+                      exitWith (ExitFailure 2)
+
+          let appstate@AppState{dirs = Dirs{..}
+                               , ghcupInfo = GHCupInfo { _ghcupDownloads = dls, .. }
+                               } = AppState settings dirs keybindings ghcupInfo pfreq
+
+          case optCommand of
+            Upgrade _ _ -> pure ()
+            _ -> runLogger $ flip runReaderT appstate $ checkForUpdates
+
+
+          -- ensure global tools
+          (siletRunLogger $ flip runReaderT appstate $ runE ensureGlobalTools) >>= \case
+            VRight _ -> pure ()
+            VLeft e -> do
+              runLogger
+                ($(logError) $ T.pack $ prettyShow e)
+              exitWith (ExitFailure 30)


          -------------------------
          -- Effect interpreters --
          -------------------------

-          let runInstTool' appstate' =
+          let runInstTool' appstate' mInstPlatform =
                runLogger
-                  . flip runReaderT appstate'
+                  . flip runReaderT (maybe appstate' (\x -> appstate'{ pfreq = x }) mInstPlatform)
                  . runResourceT
                  . runE
                    @'[ AlreadyInstalled
@@ -1208,57 +1255,22 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      ]


-          ----------------------------------------
-          -- Getting download and platform info --
-          ----------------------------------------
-
-          pfreq <- (
-            runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
-            ) >>= \case
-                    VRight r -> pure r
-                    VLeft e -> do
-                      runLogger
-                        ($(logError) $ T.pack $ prettyShow e)
-                      exitWith (ExitFailure 2)
-
-
-          (GHCupInfo treq dls) <-
-            ( runLogger
-              . flip runReaderT appstate
-              . runE @'[JSONError , DownloadFailed, FileDoesNotExistError]
-              $ liftE
-              $ getDownloadsF (urlSource settings)
-              )
-              >>= \case
-                    VRight r -> pure r
-                    VLeft  e -> do
-                      runLogger
-                        ($(logError) $ T.pack $ prettyShow e)
-                      exitWith (ExitFailure 2)
-
-          case optCommand of
-            Upgrade _ _ -> pure ()
-            _ -> runLogger $ flip runReaderT appstate $ checkForUpdates dls pfreq
-
-
-
          -----------------------
          -- Command functions --
          -----------------------

          let installGHC InstallOptions{..} =
                  (case instBindist of
-                     Nothing -> runInstTool $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
-                       liftE $ installGHCBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                     Nothing -> runInstTool instPlatform $ do
+                       (v, vi) <- liftE $ fromVersion instVer GHC
+                       liftE $ installGHCBin (_tvVersion v)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
                       pure vi
-                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
+                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} instPlatform $ do
+                       (v, vi) <- liftE $ fromVersion instVer GHC
                       liftE $ installGHCBindist
                         (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                         (_tvVersion v)
-                         (fromMaybe pfreq instPlatform)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
                       pure vi
                    )
@@ -1274,8 +1286,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                            pure ExitSuccess
                          VLeft err@(V (BuildFailed tmpdir _)) -> do
                            case keepDirs settings of
-                              Never -> runLogger ($(logError) $ T.pack $ prettyShow err)
-                              _ -> runLogger ($(logError) [i|#{prettyShow err}
+                              Never -> myLoggerT loggerConfig $ ($(logError) $ T.pack $ prettyShow err)
+                              _ -> myLoggerT loggerConfig $ ($(logError) [i|#{prettyShow err}
    Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
    Make sure to clean up #{tmpdir} afterwards.|])
                            pure $ ExitFailure 3
@@ -1288,16 +1300,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let installCabal InstallOptions{..} =
                (case instBindist of
-                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
-                     liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                   Nothing -> runInstTool instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer Cabal
+                     liftE $ installCabalBin (_tvVersion v)
                     pure vi
-                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer Cabal
                     liftE $ installCabalBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
-                         (fromMaybe pfreq instPlatform)
                     pure vi
                  )
                  >>= \case
@@ -1318,16 +1329,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let installHLS InstallOptions{..} =
                (case instBindist of
-                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
-                     liftE $ installHLSBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                   Nothing -> runInstTool instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer HLS
+                     liftE $ installHLSBin (_tvVersion v)
                     pure vi
-                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer HLS
                     liftE $ installHLSBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
-                         (fromMaybe pfreq instPlatform)
                     pure vi
                  )
                  >>= \case
@@ -1348,16 +1358,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let installStack InstallOptions{..} =
                (case instBindist of
-                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Stack
-                     liftE $ installStackBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                   Nothing -> runInstTool instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer Stack
+                     liftE $ installStackBin (_tvVersion v)
                     pure vi
-                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Stack
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer Stack
                     liftE $ installStackBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
-                         (fromMaybe pfreq instPlatform)
                     pure vi
                  )
                  >>= \case
@@ -1379,7 +1388,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let setGHC' SetOptions{..} =
                runSetGHC (do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer GHC
+                    v <- liftE $ fst <$> fromVersion' sToolVer GHC
                    liftE $ setGHC v SetGHCOnly
                  )
                  >>= \case
@@ -1394,7 +1403,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let setCabal' SetOptions{..} =
                runSetCabal (do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer Cabal
+                    v <- liftE $ fst <$> fromVersion' sToolVer Cabal
                    liftE $ setCabal (_tvVersion v)
                    pure v
                  )
@@ -1410,7 +1419,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let setHLS' SetOptions{..} =
                runSetHLS (do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer HLS
+                    v <- liftE $ fst <$> fromVersion' sToolVer HLS
                    liftE $ setHLS (_tvVersion v)
                    pure v
                  )
@@ -1426,7 +1435,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let setStack' SetOptions{..} =
                runSetCabal (do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer Stack
+                    v <- liftE $ fst <$> fromVersion' sToolVer Stack
                    liftE $ setStack (_tvVersion v)
                    pure v
                  )
@@ -1502,7 +1511,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          res <- case optCommand of
 #if defined(BRICK)
-            Interactive -> liftIO $ brickMain appstate loggerConfig dls pfreq >> pure ExitSuccess
+            Interactive -> do
+              liftIO $ brickMain appstate loggerConfig ghcupInfo >> pure ExitSuccess
 #endif
            Install (Right iopts) -> do
              runLogger ($(logWarn) [i|This is an old-style command for installing GHC. Use 'ghcup install ghc' instead.|])
@@ -1525,7 +1535,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

            List ListOptions {..} ->
              runListGHC (do
-                  l <- listVersions dls loTool lCriteria pfreq
+                  l <- listVersions loTool lCriteria
                  liftIO $ printListResult lRawFormat l
                  pure ExitSuccess
                )
@@ -1559,14 +1569,13 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        "...waiting for 5 seconds, you can still abort..."
                      liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
                  Right _ -> pure ()
-                targetVer <- liftE $ compileGHC dls
+                targetVer <- liftE $ compileGHC
                            (first (GHCTargetVersion crossTarget) targetGhc)
                            bootstrapGhc
                            jobs
                            buildConfig
                            patchDir
                            addConfArgs
-                            pfreq
                let vi = getVersionInfo (_tvVersion targetVer) GHC dls
                when setCompile $ void $ liftE $
                  setGHC targetVer SetGHCOnly
@@ -1585,8 +1594,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        pure ExitSuccess
                      VLeft err@(V (BuildFailed tmpdir _)) -> do
                        case keepDirs settings of
-                          Never -> runLogger $ $(logError) $ T.pack $ prettyShow err
-                          _ -> runLogger ($(logError) [i|#{prettyShow err}
+                          Never -> myLoggerT loggerConfig $ $(logError) $ T.pack $ prettyShow err
+                          _ -> myLoggerT loggerConfig $ ($(logError) [i|#{prettyShow err}
 Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
 Make sure to clean up #{tmpdir} afterwards.|])
                        pure $ ExitFailure 9
@@ -1600,7 +1609,7 @@ Make sure to clean up #{tmpdir} afterwards.|])
                (UpgradeAt p)   -> pure $ Just p
                UpgradeGHCupDir -> pure (Just (binDir </> "ghcup"))

-              runUpgrade (liftE $ upgradeGHCup dls target force pfreq) >>= \case
+              runUpgrade (liftE $ upgradeGHCup target force) >>= \case
                VRight v' -> do
                  let pretty_v = prettyVer v'
                  let vi = fromJust $ snd <$> getLatest dls GHCup
@@ -1617,12 +1626,13 @@ Make sure to clean up #{tmpdir} afterwards.|])
                  pure $ ExitFailure 11

            ToolRequirements ->
-              runLogger
+              flip runReaderT appstate
+              $ runLogger
                (runE
                  @'[NoCompatiblePlatform , DistroNotFound , NoToolRequirements]
                $ do
                    platform <- liftE getPlatform
-                    req      <- getCommonRequirements platform treq ?? NoToolRequirements
+                    req      <- getCommonRequirements platform _toolRequirements ?? NoToolRequirements
                    liftIO $ T.hPutStr stdout (prettyRequirements req)
                )
                >>= \case
@@ -1658,6 +1668,7 @@ Make sure to clean up #{tmpdir} afterwards.|])

                  if clOpen
                    then
+                      flip runReaderT appstate $
                      exec cmd
                           [T.unpack $ decUTF8Safe $ serializeURIRef' uri]
                           Nothing
@@ -1674,36 +1685,40 @@ Make sure to clean up #{tmpdir} afterwards.|])
  pure ()

 fromVersion :: (MonadLogger m, MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-            => GHCupDownloads
-            -> Maybe ToolVersion
+            => Maybe ToolVersion
            -> Tool
            -> Excepts '[TagNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe VersionInfo)
-fromVersion av tv = fromVersion' av (toSetToolVer tv)
+fromVersion tv = fromVersion' (toSetToolVer tv)

 fromVersion' :: (MonadLogger m, MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-             => GHCupDownloads
-             -> SetToolVersion
+             => SetToolVersion
             -> Tool
             -> Excepts '[TagNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe VersionInfo)
-fromVersion' av SetRecommended tool =
-  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended av tool
+fromVersion' SetRecommended tool = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended dls tool
    ?? TagNotFound Recommended tool
-fromVersion' av (SetToolVersion v) tool = do
-  let vi = getVersionInfo (_tvVersion v) tool av
+fromVersion' (SetToolVersion v) tool = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  let vi = getVersionInfo (_tvVersion v) tool dls
  case pvp $ prettyVer (_tvVersion v) of
    Left _ -> pure (v, vi)
    Right (PVP (major' :|[minor'])) ->
-      case getLatestGHCFor (fromIntegral major') (fromIntegral minor') av of
+      case getLatestGHCFor (fromIntegral major') (fromIntegral minor') dls of
        Just (v', vi') -> pure (GHCTargetVersion (_tvTarget v) v', Just vi')
        Nothing -> pure (v, vi)
    Right _ -> pure (v, vi)
-fromVersion' av  (SetToolTag Latest) tool =
-  (\(x, y) -> (mkTVer x, Just y)) <$> getLatest av tool ?? TagNotFound Latest tool
-fromVersion' av (SetToolTag Recommended) tool =
-  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended av tool ?? TagNotFound Recommended tool
-fromVersion' av (SetToolTag (Base pvp'')) GHC =
-  (\(x, y) -> (mkTVer x, Just y)) <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
-fromVersion' av SetNext tool = do
+fromVersion' (SetToolTag Latest) tool = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  (\(x, y) -> (mkTVer x, Just y)) <$> getLatest dls tool ?? TagNotFound Latest tool
+fromVersion' (SetToolTag Recommended) tool = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended dls tool ?? TagNotFound Recommended tool
+fromVersion' (SetToolTag (Base pvp'')) GHC = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  (\(x, y) -> (mkTVer x, Just y)) <$> getLatestBaseVersion dls pvp'' ?? TagNotFound (Base pvp'') GHC
+fromVersion' SetNext tool = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
  next <- case tool of
    GHC -> do
      set <- fmap _tvVersion $ ghcSet Nothing !? NoToolVersionSet tool
@@ -1746,17 +1761,14 @@ fromVersion' av SetNext tool = do
        . sort
        $ stacks) ?? NoToolVersionSet tool
    GHCup -> fail "GHCup cannot be set"
-  let vi = getVersionInfo (_tvVersion next) tool av
+  let vi = getVersionInfo (_tvVersion next) tool dls
  pure (next, vi)
-fromVersion' _ (SetToolTag t') tool =
+fromVersion' (SetToolTag t') tool =
  throwE $ TagNotFound t' tool


 printListResult :: Bool -> [ListResult] -> IO ()
 printListResult raw lr = do
-  -- https://gitlab.haskell.org/ghc/ghc/issues/8118
-  setLocaleEncoding utf8
-
  no_color <- isJust <$> lookupEnv "NO_COLOR"

  let
@@ -1780,9 +1792,15 @@ printListResult raw lr = do
        . fmap
            (\ListResult {..} ->
              let marks = if
+#if defined(IS_WINDOWS)
+                    | lSet       -> (color Green "IS")
+                    | lInstalled -> (color Green "I ")
+                    | otherwise  -> (color Red "X ")
+#else
                    | lSet       -> (color Green "✔✔")
                    | lInstalled -> (color Green "✓ ")
                    | otherwise  -> (color Red "✗ ")
+#endif
              in
                (if raw then [] else [marks])
                  ++ [ fmap toLower . show $ lTool
@@ -1909,11 +1927,10 @@ checkForUpdates :: ( MonadReader AppState m
                   , MonadFail m
                   , MonadLogger m
                   )
-                => GHCupDownloads
-                -> PlatformRequest
-                -> m ()
-checkForUpdates dls pfreq = do
-  lInstalled <- listVersions dls Nothing (Just ListInstalled) pfreq
+                => m ()
+checkForUpdates = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+  lInstalled <- listVersions Nothing (Just ListInstalled)
  let latestInstalled tool = (fmap lVer . lastMay . filter (\lr -> lTool lr == tool)) lInstalled

  forM_ (getLatest dls GHCup) $ \(l, _) -> do
--- a/312
+++ b/312
@@ -14,26 +14,51 @@
 # safety subshell to avoid executing anything in case this script is not downloaded properly
 (

-: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
+plat="$(uname -s)"
+arch=$(uname -m)
+ghver="0.1.14.1"
+base_url="https://downloads.haskell.org/~ghcup"

-export GHCUP_USE_XDG_DIRS
+case "${plat}" in
+        MSYS*|MINGW*)
+			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
+			GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/ghcup
+			GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/ghcup/bin
+			;;
+		*)
+			: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
+			export GHCUP_USE_XDG_DIRS

-if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
-	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
-	GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
-else
-	GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
-	GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
-fi
+			if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
+				GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
+				GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
+			else
+				GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
+				GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
+			fi
+			;;
+esac

 : "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
 : "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"

+
 die() {
    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
    exit 2
 }

+warn() {
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo -e "\\033[0;35m$1\\033[0m"
+				;;
+			*)
+				printf "\\033[0;35m%s\\033[0m\\n" "$1"
+				;;
+	esac
+}
+
 edo() {
    "$@" || die "\"$*\" failed!"
 }
@@ -43,92 +68,133 @@ eghcup() {
 }

 _eghcup() {
+	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
+		args="-s ${BOOTSTRAP_HASKELL_YAML}"
+	fi 
    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        ghcup "$@"
+        ghcup ${args} "$@"
    else
-        ghcup --verbose "$@"
+        ghcup ${args} --verbose "$@"
    fi
 }

 _done() {
-	echo
-    echo "All done!"
-	echo
-	echo "To start a simple repl, run:"
-	echo "  ghci"
-	echo
-	echo "To start a new haskell project in the current directory, run:"
-	echo "  cabal init --interactive"
-	echo
-	echo "To install other GHC versions, run:"
-	echo "  ghcup tui"
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo
+				echo "All done!"
+				echo
+				echo "In a new powershell or cmd.exe session, now you can..."
+				echo
+				echo "Start a simple repl via:"
+				echo "  ghci"
+				echo
+				echo "Start a new haskell project in the current directory via:"
+				echo "  cabal init --interactive"
+				echo
+				echo "Install other GHC versions and tools via:"
+				echo "  ghcup list"
+				echo "  ghcup install <tool> <version>"
+				echo
+				echo "To install system libraries and update msys2/mingw64,"
+				echo "open the \"Mingw haskell shell\""
+				echo "and the \"Mingw package management docs\""
+				echo "desktop shortcuts."
+				;;
+			*)
+				echo
+				echo "All done!"
+				echo
+				echo "To start a simple repl, run:"
+				echo "  ghci"
+				echo
+				echo "To start a new haskell project in the current directory, run:"
+				echo "  cabal init --interactive"
+				echo
+				echo "To install other GHC versions and tools, run:"
+				echo "  ghcup tui"
+				;;
+
+	esac
+

 	exit 0
 }

 download_ghcup() {
-	_plat="$(uname -s)"
-	_arch=$(uname -m)
-	_ghver="0.1.14.1"
-	_base_url="https://downloads.haskell.org/~ghcup"

-    case "${_plat}" in
+    case "${plat}" in
        "linux"|"Linux")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
 					# we could be in a 32bit docker container, in which
 					# case uname doesn't give us what we want
 					if [ "$(getconf LONG_BIT)" = "32" ] ; then
-						_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
+						_url=${base_url}/${ghver}/i386-linux-ghcup-${ghver}
 					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
-						_url=${_base_url}/${_ghver}/x86_64-linux-ghcup-${_ghver}
+						_url=${base_url}/${ghver}/x86_64-linux-ghcup-${ghver}
 					else
 						die "Unknown long bit size: $(getconf LONG_BIT)"
 					fi
 					;;
 				i*86)
-					_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
+					_url=${base_url}/${ghver}/i386-linux-ghcup-${ghver}
 					;;
 				armv7*)
-					_url=${_base_url}/${_ghver}/armv7-linux-ghcup-${_ghver}
+					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
 					;;
 				aarch64|arm64|armv8l)
-					_url=${_base_url}/${_ghver}/aarch64-linux-ghcup-${_ghver}
+					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
 			;;
        "FreeBSD"|"freebsd")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
-			_url=${_base_url}/${_ghver}/x86_64-portbld-freebsd-ghcup-${_ghver}
+			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
            ;;
        "Darwin"|"darwin")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
-			_url=${_base_url}/${_ghver}/x86_64-apple-darwin-ghcup-${_ghver} ;;
-        *) die "Unknown platform: ${_plat}"
+			_url=${base_url}/${ghver}/x86_64-apple-darwin-ghcup-${ghver} ;;
+        MSYS*|MINGW*)
+			case "${arch}" in
+				x86_64|amd64)
+					_url=https://downloads.haskell.org/~ghcup/tmp/x86_64-mingw64-ghcup-7.exe
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			;;
+        *) die "Unknown platform: ${plat}"
 			;;
    esac
-
-	edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
-
-    edo chmod +x "${GHCUP_BIN}"/ghcup
+    case "${plat}" in
+        MSYS*|MINGW*)
+			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup.exe
+			edo chmod +x "${GHCUP_BIN}"/ghcup.exe
+			;;
+		*)
+			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
+			edo chmod +x "${GHCUP_BIN}"/ghcup
+			;;
+	esac

  edo mkdir -p "${GHCUP_DIR}"
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
@@ -137,8 +203,6 @@ download_ghcup() {
 	# shellcheck disable=SC1090
    edo . "${GHCUP_DIR}"/env
    eghcup upgrade
-
-	unset _plat _arch _url _ghver _base_url
 }


@@ -147,14 +211,22 @@ echo "Welcome to Haskell!"
 echo
 echo "This script will download and install the following binaries:"
 echo "  * ghcup - The Haskell toolchain installer"
-echo "            (for managing GHC/cabal versions)"
 echo "  * ghc   - The Glasgow Haskell Compiler"
-echo "  * cabal - The Cabal build tool"
+echo "  * cabal - The Cabal build tool for managing Haskell software"
+echo "  * stack - (optional) A cross-platform program for developing Haskell projects"
+echo "  * hls   - (optional) A language server for developers to integrate with their editor/IDE"
 echo
 if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
 	echo "ghcup installs only into the following directory,"
    echo "which can be removed anytime:"
-	echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo "  $(cygpath -w "$GHCUP_DIR")"
+				;;
+			*)
+				echo "  $GHCUP_DIR"
+				;;
+	esac
 else
 	echo "ghcup installs into XDG directories as long as"
    echo "'GHCUP_USE_XDG_DIRS' is set."
@@ -162,8 +234,8 @@ fi
 echo

 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Note that this script can be re-run at any given time."
+    warn "Press ENTER to proceed or ctrl-c to abort."
+    warn "Note that this script can be re-run at any given time."
    echo
    # Wait for user input to continue.
    # shellcheck disable=SC2034
@@ -181,12 +253,12 @@ else
 fi

 echo
-echo "$(ghcup tool-requirements)"
+echo "$(if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then ghcup -s "${BOOTSTRAP_HASKELL_YAML}" tool-requirements ; else ghcup tool-requirements ; fi)"
 echo

 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Installation may take a while."
+    warn "Press ENTER to proceed or ctrl-c to abort."
+    warn "Installation may take a while."
    echo

    # Wait for user input to continue.
@@ -199,21 +271,54 @@ eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
 eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
 eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"

+adjust_cabal_config() {
+	edo cabal user-config -a "extra-prog-path: $(cygpath -w $GHCUP_BIN), $(cygpath -w "$HOME"/AppData/Roaming/cabal/bin), $(cygpath -w "$GHCUP_DIR"/msys64/usr/bin), $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/lib)" -f init
+}
+
+case "${plat}" in
+        MSYS*|MINGW*)
+			if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+				warn "Create an initial cabal.config including relevant msys2 paths (recommended)?"
+				warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+				echo
+				while true; do
+					read -r mingw_answer </dev/tty
+
+					case $mingw_answer in
+						[Yy]* | "")
+							adjust_cabal_config
+							break ;;
+						[Nn]*)
+							echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
+							sleep 5
+							break ;;
+						*)
+							echo "Possible choices are:"
+							echo
+							echo "Y - Yes, create a cabal.config with pre-set paths to msys2/mingw64 (default)"
+							echo "N - No, leave the current/default cabal config untouched"
+							echo
+							echo "Please make your choice and press ENTER."
+							;;
+					esac
+				done
+			else
+				adjust_cabal_config
+			fi
+			;;
+esac
+
+
 edo cabal new-update

-printf "\\033[0;35m%s\\033[0m\\n" ""
-printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
-printf "\\033[0;35m%s\\033[0m\\n" ""
-
-
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-	printf "\\033[0;35m%s\\033[0m\\n" "Do you want to install haskell-language-server (HLS) now?"
-	printf "\\033[0;35m%s\\033[0m\\n" "HLS is a language-server that provides IDE-like functionality"
-	printf "\\033[0;35m%s\\033[0m\\n" "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
-	printf "\\033[0;35m%s\\033[0m\\n" "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-	printf "\\033[0;35m%s\\033[0m\\n" "Answer with YES or NO and press ENTER."
-	printf "\\033[0;35m%s\\033[0m\\n" ""
+	warn "Do you want to install haskell-language-server (HLS) now?"
+	warn "HLS is a language-server that provides IDE-like functionality"
+	warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""

 	while true; do
 		read -r hls_answer </dev/tty
@@ -222,10 +327,43 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 			[Yy]*)
 				eghcup --cache install hls
 				break ;;
-			[Nn]*)
+			[Nn]* | "")
 				break ;;
 			*)
-				echo "Please type YES or NO and press enter.";;
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install the haskell-langauge-server"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
+		esac
+	done
+
+	warn "Do you want to install stack now?"
+	warn "Stack is a haskell build tool similar to cabal that is used by some projects."
+	warn "Also see https://docs.haskellstack.org/"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""
+
+	while true; do
+		read -r stack_answer </dev/tty
+
+		case $stack_answer in
+			[Yy]*)
+				eghcup --cache install stack
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install stack"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
 		esac
 	done

@@ -258,17 +396,20 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 	esac


-	printf "\\033[0;35m%s\\033[0m\\n" ""
-	printf "\\033[0;35m%s\\033[0m\\n" "Detected ${MY_SHELL} shell on your system..."
-	printf "\\033[0;35m%s\\033[0m\\n" "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
-	printf "\\033[0;35m%s\\033[0m\\n" "answer with YES, otherwise with NO and press ENTER."
-	printf "\\033[0;35m%s\\033[0m\\n" ""
+	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 ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+	warn ""

    while true; do
        read -r next_answer </dev/tty

        case $next_answer in
-            [Yy]*)
+            [Nn]*)
+                _done ;;
+            [Yy]* | "")
 				case $MY_SHELL in
 					"") break ;;
 					fish)
@@ -283,7 +424,7 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
 							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
 						fi
-						case "$(uname -s)" in
+						case "${plat}" in
 							"Darwin"|"darwin")
 								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
 									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
@@ -298,17 +439,24 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 						fi
 						break ;;
 				esac
-                printf "\\033[0;35m%s\\033[0m\\n" "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
-                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
+                warn "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
+                warn "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
 				_done
                ;;
-            [Nn]*)
-                _done ;;
-            *)
-                echo "Please type YES or NO and press enter.";;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, update my \"${GHCUP_PROFILE_FILE}\" (default)"
+				echo "N - No, don't mess with my configuration"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
        esac
    done
 fi
+
+_done
+
 )

 # vim: tabstop=4 shiftwidth=4 expandtab
--- a/bootstrap-haskell.ps1
+++ b/bootstrap-haskell.ps1
@@ -0,0 +1,194 @@
+function Print-Msg {
+  param ( [Parameter(Mandatory=$true, HelpMessage='String to output')][string]$msg )
+  Write-Host ('{0}' -f $msg) -ForegroundColor Green
+}
+
+function Create-Shortcut {
+    param ( [Parameter(Mandatory=$true,HelpMessage='Target path')][string]$SourceExe, [Parameter(Mandatory=$true,HelpMessage='Arguments to the path/exe')][AllowEmptyString()]$ArgumentsToSourceExe, [Parameter(Mandatory=$true,HelpMessage='The destination of the desktop link')][string]$DestinationPath )
+    $WshShell = New-Object -comObject WScript.Shell
+    $Shortcut = $WshShell.CreateShortcut($DestinationPath)
+    $Shortcut.TargetPath = $SourceExe
+    if($ArgumentsToSourceExe) {
+      $Shortcut.Arguments = $ArgumentsToSourceExe
+    }
+    $Shortcut.Save()
+}
+
+function Add-EnvPath {
+    param(
+        [Parameter(Mandatory=$true,HelpMessage='The Pathe to add to Users environment')]
+        [string] $Path,
+
+        [ValidateSet('Machine', 'User', 'Session')]
+        [string] $Container = 'Session'
+    )
+
+    function Where-Something
+    {
+      param
+      (
+        [Parameter(Mandatory=$true, ValueFromPipeline=$true, HelpMessage='Data to filter')]
+        $InputObject
+      )
+      process
+      {
+        if ($InputObject)
+        {
+          $InputObject
+        }
+      }
+    }
+
+  if ($Container -ne 'Session') {
+        $containerMapping = @{
+            Machine = [EnvironmentVariableTarget]::Machine
+            User = [EnvironmentVariableTarget]::User
+        }
+        $containerType = $containerMapping[$Container]
+
+        $persistedPaths = [Environment]::GetEnvironmentVariable('Path', $containerType) -split ';'
+        if ($persistedPaths -notcontains $Path) {
+            $persistedPaths = $persistedPaths + $Path | Where-Something
+            [Environment]::SetEnvironmentVariable('Path', $persistedPaths -join ';', $containerType)
+        }
+    }
+
+    $envPaths = $env:Path -split ';'
+    if ($envPaths -notcontains $Path) {
+        $envPaths = $envPaths + $Path | Where-Something
+        $env:Path = $envPaths -join ';'
+    }
+}
+
+filter Get-FileSize {
+	'{0:N2} {1}' -f $(
+	if ($_ -lt 1kb) { $_, 'Bytes' }
+	elseif ($_ -lt 1mb) { ($_/1kb), 'KB' }
+	elseif ($_ -lt 1gb) { ($_/1mb), 'MB' }
+	elseif ($_ -lt 1tb) { ($_/1gb), 'GB' }
+	elseif ($_ -lt 1pb) { ($_/1tb), 'TB' }
+	else { ($_/1pb), 'PB' }
+	)
+}
+
+function Get-FileWCSynchronous{
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$url, 
+        [string]$destinationFolder="$env:USERPROFILE\Downloads",
+        [switch]$includeStats
+    )
+    $wc = New-Object -TypeName Net.WebClient
+    $wc.UseDefaultCredentials = $true
+    $destination = Join-Path -Path $destinationFolder -ChildPath ($url | Split-Path -Leaf)
+    $start = Get-Date
+    $wc.DownloadFile($url, $destination)
+    $elapsed = ((Get-Date) - $start).ToString('hh\:mm\:ss')
+    $totalSize = (Get-Item -Path $destination).Length | Get-FileSize
+    if ($includeStats.IsPresent){
+        [PSCustomObject]@{Name=$MyInvocation.MyCommand;TotalSize=$totalSize;Time=$elapsed}
+    }
+    Get-Item -Path $destination | Unblock-File
+}
+
+$ErrorActionPreference = 'Stop'
+
+$GhcupDir = "$env:HOMEDRIVE\ghcup"
+$MsysDir = ('{0}\msys64' -f $GhcupDir)
+$Bash = ('{0}\usr\bin\bash' -f $MsysDir)
+
+Print-Msg -msg 'Preparing for GHCup installation...'
+
+if (Test-Path -Path ('{0}' -f $GhcupDir)) {
+  $decision = $Host.UI.PromptForChoice('Install', 'GHCup is already installed, what do you want to do?', @('&Reinstall'
+                                                                                                           '&Continue'
+                                                                                                           '&Abort'), 1)
+  if ($decision -eq 0) {
+    $suffix = [IO.Path]::GetRandomFileName()
+    Print-Msg -msg ('Backing up {0} to {0}-{1} ...' -f $GhcupDir, $suffix)
+    Rename-Item -Path ('{0}' -f $GhcupDir) -NewName ('{0}-{1}' -f $GhcupDir, $suffix)
+  } elseif ($decision -eq 1) {
+    Print-Msg -msg 'Continuing installation...'
+  } elseif ($decision -eq 2) {
+    Exit
+  }
+}
+
+
+$null = New-Item -Path ('{0}' -f $GhcupDir) -ItemType 'directory' -ErrorAction SilentlyContinue
+$null = New-Item -Path ('{0}' -f $GhcupDir) -Name 'bin' -ItemType 'directory' -ErrorAction SilentlyContinue
+
+Print-Msg -msg 'First checking for Msys2...'
+
+if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
+    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0} ...this may take a while' -f $MsysDir)
+
+    # Download the archive
+    Print-Msg -msg 'Downloading Msys2 archive...'
+    $archive = 'msys2-x86_64-latest.sfx.exe'
+    
+    if (Get-Command -Name 'curl.exe' -ErrorAction SilentlyContinue) {
+      curl.exe -o ('{0}\{1}' -f $env:TEMP, $archive) ('https://repo.msys2.org/distrib/{0}' -f $archive)
+    } else {
+      Get-FileWCSynchronous -url ('https://repo.msys2.org/distrib/{0}' -f $archive) -destinationFolder "$env:TEMP" -includeStats
+    }
+
+    Print-Msg -msg 'Extracting Msys2 archive...'
+    $null = & "$env:TEMP\$archive" '-y' ('-o{0}' -f $GhcupDir)  # Extract
+    Remove-Item -Path ('{0}/{1}' -f $env:TEMP, $archive)
+
+    Print-Msg -msg 'Processing MSYS2 bash for first time use...'
+    & "$Bash" -lc 'exit'
+
+    & "$env:windir\system32\taskkill.exe" /F /FI `"MODULES eq msys-2.0.dll`"
+
+    Print-Msg -msg 'Upgrading full system...'
+    & "$Bash" -lc 'pacman --noconfirm -Syuu'
+
+    Print-Msg -msg 'Upgrading full system twice...'
+    & "$Bash" -lc 'pacman --noconfirm -Syuu'
+
+    Print-Msg -msg 'Installing GHC Build Dependencies...'
+    & "$Bash" -lc 'pacman --noconfirm -S --needed git tar curl wget base-devel gettext binutils autoconf make libtool automake python p7zip patch unzip mingw-w64-x86_64-toolchain mingw-w64-x86_64-gcc mingw-w64-x86_64-gdb mingw-w64-x86_64-python2 mingw-w64-x86_64-python3-sphinx'
+
+    Print-Msg -msg 'Updating SSL root certificate authorities...'
+    & "$Bash" -lc 'pacman --noconfirm -S ca-certificates'
+
+    Print-Msg -msg 'Setting default home directory...'
+    & "$Bash" -lc "sed -i -e 's/db_home:.*$/db_home: windows/' /etc/nsswitch.conf"
+} else {
+    Print-Msg -msg ('...Msys2 found in {0} ...skipping Msys2 installation.' -f $MsysDir)
+}
+
+Print-Msg -msg 'Creating shortcuts...'
+Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe '-mingw64' -DestinationPath ('{0}\Desktop\Mingw haskell shell.lnk' -f $HOME)
+Create-Shortcut -SourceExe 'https://www.msys2.org/docs/package-management' -ArgumentsToSourceExe '' -DestinationPath ('{0}\Desktop\Mingw package management docs.url' -f $HOME)
+
+Print-Msg -msg ('Adding {0}\bin to Users Path...' -f $GhcupDir)
+Add-EnvPath -Path ('{0}\bin' -f $GhcupDir) -Container 'User'
+
+Print-Msg -msg 'Starting GHCup installer...'
+& "$Bash" -lc "export PATH=`"/c/ghcup/bin:`$PATH`" ; curl --proto =https --tlsv1.2 -sSf https://gitlab.haskell.org/haskell/ghcup-hs/-/raw/windows-support/bootstrap-haskell | bash"
+# SIG # Begin signature block
+  # MIID4QYJKoZIhvcNAQcCoIID0jCCA84CAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB
+  # gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR
+  # AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUVqKek181kF/Jx/P7z176herc
+  # ZyCgggH/MIIB+zCCAWSgAwIBAgIQGOezhGS1A5tHh9VubW0liDANBgkqhkiG9w0B
+  # AQUFADAYMRYwFAYDVQQDDA1KdWxpYW4gT3NwYWxkMB4XDTIxMDUzMDE4Mzk1OVoX
+  # DTI1MDUzMDAwMDAwMFowGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZDCBnzANBgkq
+  # hkiG9w0BAQEFAAOBjQAwgYkCgYEAs76XCXYPM14buR1RkVKhOB8pyM4Df6kPaz75
+  # nkbA0nq1VmMhBfCYFWyYHd7jniqTH0LoAKGGquN1bniREaCP9j2pFWpMIgLpQH3H
+  # +jpsfmxV2BTG8q+Jok88gTXS1FlAk72E85zO/Jhr6Fja1aFYAdibBRsRxcVMTVh7
+  # 4AGLNGUCAwEAAaNGMEQwEwYDVR0lBAwwCgYIKwYBBQUHAwMwHQYDVR0OBBYEFC+R
+  # hdhPo0Ty5HnzHyo1pN35IfZQMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQUF
+  # AAOBgQAl3IdBVIwbJJDp7BksMYPeM4ivB3UyNvlw8aVxGwAzNgdSaezYIdMFtKXV
+  # CSv5bd4VnFRAPDJW9dhW0h3SkeJUoklUxMjKXhR3qygQhSxPDjIatAuOCffGACba
+  # ZZ7Om40b+pKXc6i/HnlApk9DGbXJ59bFcLGGcZ9QjoUae6Ex1DGCAUwwggFIAgEB
+  # MCwwGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZAIQGOezhGS1A5tHh9VubW0liDAJ
+  # BgUrDgMCGgUAoHgwGAYKKwYBBAGCNwIBDDEKMAigAoAAoQKAADAZBgkqhkiG9w0B
+  # CQMxDAYKKwYBBAGCNwIBBDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAj
+  # BgkqhkiG9w0BCQQxFgQUosm9nN1JgajqSBa1cUwxxhLrAsYwDQYJKoZIhvcNAQEB
+  # BQAEgYCnKzfsH1aDjS6xkC/uymjaBowHSnh6nFu2AkjcKu8RgcBZzP5SLBXgU9wm
+  # aED5Ujwyq3Qre+TGVRUqwkEauDhQiX2A008G00fRO6+di6yJRCRn5eaRAbdU3Xww
+  # E5VhEwLBnwzWrvLKtdEclhgUCo5Tq87QMXVdgX4aRmunl4ZE+Q==
+# SIG # End signature block
--- a/cabal.project
+++ b/cabal.project
@@ -2,11 +2,8 @@ packages: ./ghcup.cabal

 optimization: 2

-package streamly
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-
 package ghcup
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+    ghc-options: -O2 -rtsopts
    tests: True
    flags: +tui

@@ -20,4 +17,4 @@ constraints: http-io-streams -brotli
 package libarchive
  flags: -system-libarchive

-allow-newer: base, ghc-prim, template-haskell
+allow-newer: base, ghc-prim, template-haskell, language-c
--- a/ghcup-0.0.4.yaml
+++ b/ghcup-0.0.4.yaml
@@ -127,6 +127,13 @@ toolRequirements:
          - libffi
          - libiconv
          notes: ''
+      Windows:
+        unknown_versioning:
+          distroPKGs: []
+          notes: On Windows, msys2 should already have been set up during the installation,
+            so most users should just press ENTER.
+            If you are installing manually, make sure to have a working mingw64 toolchain and
+            shell.
 ghcupDownloads:
  GHC:
    7.10.3:
@@ -1929,8 +1936,8 @@ ghcupDownloads:
              dlHash: 89a70980d77888dae8b9fd0f05e7a7920f421bc3bb5192da8e73fd4e7b4cb86f
          Windows:
            unknown_versioning:
-              dlUri: https://TODO
-              dlHash: 89a70980d77888dae8b9fd0f05e7a7920f421bc3bb5192da8e73fd4e7b4cb86f
+              dlUri: https://downloads.haskell.org/ghcup/tmp/ghcup.exe
+              dlHash: e6dc0b337b29164d5e4a299e572955591b1b6e5d4d11e895c8cbc05666d98ad5
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
@@ -1977,6 +1984,7 @@ ghcupDownloads:
    2.5.1:
      viTags: []
      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"
      viArch:
        A_64:
          Linux_UnknownLinux:
@@ -2004,6 +2012,7 @@ ghcupDownloads:
        - Recommended
        - Latest
      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v271
+      viPostInstall: *stack-post
      viArch:
        A_64:
          Linux_UnknownLinux:
--- a/ghcup-0.0.5.yaml
+++ b/ghcup-0.0.5.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,6 +1,6 @@
 cabal-version:   3.0
 name:            ghcup
-version:         0.1.14.2
+version:         0.1.15
 license:         LGPL-3.0-only
 license-file:    LICENSE
 copyright:       Julian Ospald 2020
@@ -43,7 +43,7 @@ flag internal-downloader

 flag tar
  description:
-    Use tar-bytestring instead of libarchive. This is always enabled on windows.
+    Use tar-bytestring instead of libarchive.

  default:     False
  manual:      True
@@ -75,14 +75,20 @@ library
  autogen-modules:    Paths_ghcup
  default-language:   Haskell2010
  default-extensions:
+    DeriveGeneric
    LambdaCase
    MultiWayIf
+    NamedFieldPuns
    PackageImports
+    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
    Strict
    StrictData
    TupleSections
+    TypeApplications
+    TypeFamilies
+    ViewPatterns

  ghc-options:
    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
@@ -118,17 +124,14 @@ library
    , parsec                ^>=3.1
    , pretty                ^>=1.1.3.1
    , pretty-terminal       ^>=0.1.0.0
-    , process               ^>=1.6.9.0
    , regex-posix           ^>=0.96
    , resourcet             ^>=1.2.2
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
    , split                 ^>=0.2.3.4
-    , streamly              ^>=0.7.3
-    , streamly-bytestring   ^>=0.1.2
    , strict-base           ^>=0.4
    , string-interpolate    >=0.2.0.0    && <0.4
-    , template-haskell      >=2.7        && <2.17
+    , template-haskell      >=2.7        && <2.18
    , temporary             ^>=1.3
    , text                  ^>=1.2.4.0
    , time                  ^>=1.9.3
@@ -150,7 +153,7 @@ library
    build-depends:
      , HsOpenSSL              >=0.11.4.18
      , http-io-streams        >=0.1.2.0
-      , io-streams             >=1.5
+      , io-streams             >=1.5.2.1
      , terminal-progress-bar  >=0.4.1

  if (flag(tar) || os(windows))
@@ -163,14 +166,18 @@ library
  if os(windows)
    cpp-options:   -DIS_WINDOWS
    other-modules: GHCup.Utils.File.Windows
-    build-depends: bzlib
+    build-depends:
+      , bzlib
+      , process  ^>=1.6.11.0
+      , retry    ^>=0.8.1.2
+      , Win32    ^>=2.10

  else
    other-modules: GHCup.Utils.File.Posix
    build-depends:
-        bz2              >=0.5.0.5 && <1.1
+      , bz2              >=0.5.0.5 && <1.1
      , hpath-posix      ^>=0.13.3
-      , streamly-posix   ^>=0.1.0.0
+      , process          ^>=1.6.9
      , unix             ^>=2.7
      , unix-bytestring  ^>=0.3.7.3

@@ -185,6 +192,7 @@ executable ghcup
  default-extensions:
    LambdaCase
    MultiWayIf
+    NamedFieldPuns
    PackageImports
    RecordWildCards
    ScopedTypeVariables
@@ -197,7 +205,6 @@ executable ghcup
    -fwarn-incomplete-record-updates -threaded

  build-depends:
-    , aeson                 >=1.4      && <1.6
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
    , containers            ^>=0.6
@@ -214,7 +221,7 @@ executable ghcup
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
    , string-interpolate    >=0.2.0.0  && <0.4
-    , template-haskell      >=2.7      && <2.17
+    , template-haskell      >=2.7      && <2.18
    , text                  ^>=1.2.4.0
    , uri-bytestring        ^>=0.3.2.2
    , utf8-string           ^>=1.0
@@ -227,9 +234,13 @@ executable ghcup
    cpp-options:   -DBRICK
    other-modules: BrickMain
    build-depends:
-      , brick   >=0.5    && <0.62
-      , vector  ^>=0.12
-      , vty     >=5.28.2 && <5.34
+      , brick         >=0.5    && <0.62
+      , transformers  ^>=0.5
+      , vector        ^>=0.12
+      , vty           >=5.28.2 && <5.34
+
+  if os(windows)
+    cpp-options: -DIS_WINDOWS

  if (flag(tar) || os(windows))
    cpp-options: -DTAR
@@ -243,20 +254,26 @@ executable ghcup-gen
  other-modules:      Validate
  default-language:   Haskell2010
  default-extensions:
+    DeriveGeneric
    LambdaCase
    MultiWayIf
+    NamedFieldPuns
    PackageImports
+    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
+    Strict
+    StrictData
    TupleSections
+    TypeApplications
+    TypeFamilies
+    ViewPatterns

  ghc-options:
    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
    -fwarn-incomplete-record-updates -threaded

  build-depends:
-    , aeson                 >=1.4      && <1.6
-    , aeson-pretty          ^>=0.8.8
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
    , containers            ^>=0.6
@@ -276,7 +293,6 @@ executable ghcup-gen
    , text                  ^>=1.2.4.0
    , transformers          ^>=0.5
    , uri-bytestring        ^>=0.3.2.2
-    , utf8-string           ^>=1.0
    , versions              ^>=4.0.1
    , yaml                  ^>=0.11.4.0

@@ -316,7 +332,7 @@ test-suite ghcup-test
    , generic-arbitrary         ^>=0.1.0
    , ghcup
    , hspec                     ^>=2.7.10
-    , hspec-golden-aeson        >=0.9 && <0.10
+    , hspec-golden-aeson        ^>=0.9
    , QuickCheck                ^>=2.14.1
    , quickcheck-arbitrary-adt  ^>=0.3.1.0
    , text                      ^>=1.2.4.0
--- a/golden/GHCupInfo.json
+++ b/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -1,15 +1,11 @@
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
-{-# LANGUAGE TypeFamilies          #-}
-{-# LANGUAGE ViewPatterns          #-}
+{-# LANGUAGE QuasiQuotes           #-}

 {-|
 Module      : GHCup
@@ -112,7 +108,6 @@ installGHCBindist :: ( MonadFail m
                     )
                  => DownloadInfo    -- ^ where/how to download
                  -> Version         -- ^ the version to install
-                  -> PlatformRequest -- ^ the platform to install on
                  -> Excepts
                       '[ AlreadyInstalled
                        , BuildFailed
@@ -128,20 +123,22 @@ installGHCBindist :: ( MonadFail m
                        ]
                       m
                       ()
-installGHCBindist dlinfo ver pfreq = do
+installGHCBindist dlinfo ver = do
+  AppState { dirs , settings } <- lift ask
+
  let tver = mkTVer ver
  lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
  whenM (lift $ ghcInstalled tver) (throwE $ AlreadyInstalled GHC ver)

  -- download (or use cached version)
-  dl                           <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing

  -- prepare paths
  ghcdir <- lift $ ghcupGHCDir tver

  toolchainSanityChecks
  
-  liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver pfreq
+  liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver

  liftE $ postGHCInstall tver

@@ -170,7 +167,6 @@ installPackedGHC :: ( MonadMask m
                 -> Maybe TarDir      -- ^ Subdir of the archive
                 -> FilePath          -- ^ Path to install to
                 -> Version           -- ^ The GHC version
-                 -> PlatformRequest
                 -> Excepts
                      '[ BuildFailed
                       , UnknownArchive
@@ -179,11 +175,13 @@ installPackedGHC :: ( MonadMask m
                       , ArchiveResult
 #endif
                       ] m ()
-installPackedGHC dl msubdir inst ver pfreq@PlatformRequest{..} = do
+installPackedGHC dl msubdir inst ver = do
+  AppState { pfreq = PlatformRequest {..} } <- lift ask
+
  -- unpack
  tmpUnpack <- lift mkGhcupTmpDir
  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+  void $ lift $ darwinNotarization _rPlatform tmpUnpack

  -- the subdir of the archive where we do the work
  workdir <- maybe (pure tmpUnpack)
@@ -192,7 +190,7 @@ installPackedGHC dl msubdir inst ver pfreq@PlatformRequest{..} = do

  liftE $ runBuildAction tmpUnpack
                         (Just inst)
-                         (installUnpackedGHC workdir inst ver pfreq)
+                         (installUnpackedGHC workdir inst ver)


 -- | Install an unpacked GHC distribution. This only deals with the GHC
@@ -205,30 +203,36 @@ installUnpackedGHC :: ( MonadReader AppState m
                   => FilePath      -- ^ Path to the unpacked GHC bindist (where the configure script resides)
                   -> FilePath      -- ^ Path to install to
                   -> Version       -- ^ The GHC version
-                   -> PlatformRequest
                   -> Excepts '[ProcessError] m ()
 #if defined(IS_WINDOWS)
-installUnpackedGHC path inst _ _ = do
+installUnpackedGHC path inst _ = do
  lift $ $(logInfo) "Installing GHC (this may take a while)"
  -- windows bindists are relocatable and don't need
  -- to run configure
  liftIO $ copyDirectoryRecursive path inst
 #else
-installUnpackedGHC path inst ver PlatformRequest{..} = do
+installUnpackedGHC path inst ver = do
+  AppState { pfreq = PlatformRequest {..} } <- lift ask
+
+  let alpineArgs
+       | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
+       = ["--disable-ld-override"]
+       | otherwise
+       = []
+
  lift $ $(logInfo) "Installing GHC (this may take a while)"
  lEM $ execLogged "sh"
-                   ("./configure" : ("--prefix=" <> inst) : alpineArgs)
+                   ("./configure" : ("--prefix=" <> inst) 
+#if defined(IS_WINDOWS)
+                    : "--enable-tarballs-autodownload"
+#endif
+                    : alpineArgs
+                   )
                   (Just path)
                   "ghc-configure"
                   Nothing
  lEM $ make ["install"] (Just path)
  pure ()
- where
-  alpineArgs
-    | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
-    = ["--disable-ld-override"]
-    | otherwise
-    = []
 #endif


@@ -246,9 +250,7 @@ installGHCBin :: ( MonadFail m
                 , MonadIO m
                 , MonadUnliftIO m
                 )
-              => GHCupDownloads  -- ^ the download info to look up the tarball from
-              -> Version         -- ^ the version to install
-              -> PlatformRequest -- ^ the platform to install on
+              => Version         -- ^ the version to install
              -> Excepts
                   '[ AlreadyInstalled
                    , BuildFailed
@@ -264,9 +266,11 @@ installGHCBin :: ( MonadFail m
                    ]
                   m
                   ()
-installGHCBin bDls ver pfreq = do
-  dlinfo <- lE $ getDownloadInfo GHC ver pfreq bDls
-  installGHCBindist dlinfo ver pfreq
+installGHCBin ver = do
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo GHC ver pfreq dls
+  installGHCBindist dlinfo ver


 -- | Like 'installCabalBin', except takes the 'DownloadInfo' as
@@ -282,7 +286,6 @@ installCabalBindist :: ( MonadMask m
                       )
                    => DownloadInfo
                    -> Version
-                    -> PlatformRequest
                    -> Excepts
                         '[ AlreadyInstalled
                          , CopyError
@@ -298,27 +301,29 @@ installCabalBindist :: ( MonadMask m
                          ]
                         m
                         ()
-installCabalBindist dlinfo ver PlatformRequest {..} = do
+installCabalBindist dlinfo ver = do
  lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]

-  AppState {dirs = Dirs {..}} <- lift ask
+  AppState { dirs = dirs@Dirs {..}
+           , pfreq = PlatformRequest {..}
+           , settings } <- lift ask

  whenM
      (lift (cabalInstalled ver) >>= \a -> liftIO $
        handleIO (\_ -> pure False)
          $ fmap (\x -> a && x)
          -- ignore when the installation is a legacy cabal (binary, not symlink)
-          $ pathIsSymbolicLink (binDir </> "cabal" <> exeExt)
+          $ pathIsLink (binDir </> "cabal" <> exeExt)
      )
      (throwE $ AlreadyInstalled Cabal ver)

  -- download (or use cached version)
-  dl                           <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing

  -- unpack
  tmpUnpack                    <- lift withGHCupTmpDir
  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+  void $ lift $ darwinNotarization _rPlatform tmpUnpack

  -- the subdir of the archive where we do the work
  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
@@ -360,9 +365,7 @@ installCabalBin :: ( MonadMask m
                   , MonadUnliftIO m
                   , MonadFail m
                   )
-                => GHCupDownloads
-                -> Version
-                -> PlatformRequest
+                => Version
                -> Excepts
                     '[ AlreadyInstalled
                      , CopyError
@@ -378,9 +381,11 @@ installCabalBin :: ( MonadMask m
                      ]
                     m
                     ()
-installCabalBin bDls ver pfreq = do
-  dlinfo <- lE $ getDownloadInfo Cabal ver pfreq bDls
-  installCabalBindist dlinfo ver pfreq
+installCabalBin ver = do
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo Cabal ver pfreq dls
+  installCabalBindist dlinfo ver


 -- | Like 'installHLSBin, except takes the 'DownloadInfo' as
@@ -396,7 +401,6 @@ installHLSBindist :: ( MonadMask m
                     )
                  => DownloadInfo
                  -> Version
-                  -> PlatformRequest
                  -> Excepts
                       '[ AlreadyInstalled
                        , CopyError
@@ -412,21 +416,23 @@ installHLSBindist :: ( MonadMask m
                        ]
                       m
                       ()
-installHLSBindist dlinfo ver PlatformRequest{..} = do
+installHLSBindist dlinfo ver = do
  lift $ $(logDebug) [i|Requested to install hls version #{ver}|]

-  AppState {dirs = Dirs {..}} <- lift ask
+  AppState { dirs = dirs@Dirs {..}
+           , pfreq = PlatformRequest {..}
+           , settings } <- lift ask

  whenM (lift (hlsInstalled ver))
    (throwE $ AlreadyInstalled HLS ver)

  -- download (or use cached version)
-  dl                           <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing

  -- unpack
  tmpUnpack                    <- lift withGHCupTmpDir
  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+  void $ lift $ darwinNotarization _rPlatform tmpUnpack

  -- the subdir of the archive where we do the work
  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
@@ -483,9 +489,7 @@ installHLSBin :: ( MonadMask m
                 , MonadUnliftIO m
                 , MonadFail m
                 )
-              => GHCupDownloads
-              -> Version
-              -> PlatformRequest
+              => Version
              -> Excepts
                   '[ AlreadyInstalled
                    , CopyError
@@ -501,9 +505,11 @@ installHLSBin :: ( MonadMask m
                    ]
                   m
                   ()
-installHLSBin bDls ver pfreq = do
-  dlinfo <- lE $ getDownloadInfo HLS ver pfreq bDls
-  installHLSBindist dlinfo ver pfreq
+installHLSBin ver = do
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo HLS ver pfreq dls
+  installHLSBindist dlinfo ver


 -- | Installs stack into @~\/.ghcup\/bin/stack-\<ver\>@ and
@@ -518,9 +524,7 @@ installStackBin :: ( MonadMask m
                   , MonadUnliftIO m
                   , MonadFail m
                   )
-                => GHCupDownloads
-                -> Version
-                -> PlatformRequest
+                => Version
                -> Excepts
                     '[ AlreadyInstalled
                      , CopyError
@@ -536,9 +540,10 @@ installStackBin :: ( MonadMask m
                      ]
                     m
                     ()
-installStackBin bDls ver pfreq = do
-  dlinfo <- lE $ getDownloadInfo Stack ver pfreq bDls
-  installStackBindist dlinfo ver pfreq
+installStackBin ver = do
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo Stack ver pfreq dls
+  installStackBindist dlinfo ver


 -- | Like 'installStackBin', except takes the 'DownloadInfo' as
@@ -554,7 +559,6 @@ installStackBindist :: ( MonadMask m
                       )
                    => DownloadInfo
                    -> Version
-                    -> PlatformRequest
                    -> Excepts
                         '[ AlreadyInstalled
                          , CopyError
@@ -570,21 +574,24 @@ installStackBindist :: ( MonadMask m
                          ]
                         m
                         ()
-installStackBindist dlinfo ver PlatformRequest {..} = do
+installStackBindist dlinfo ver = do
  lift $ $(logDebug) [i|Requested to install stack version #{ver}|]

-  AppState {dirs = Dirs {..}} <- lift ask
+  AppState { dirs = dirs@Dirs {..}
+           , pfreq = PlatformRequest {..}
+           , settings
+           } <- lift ask

  whenM (lift (hlsInstalled ver))
    (throwE $ AlreadyInstalled Stack ver)

  -- download (or use cached version)
-  dl                           <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing

  -- unpack
  tmpUnpack                    <- lift withGHCupTmpDir
  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+  void $ lift $ darwinNotarization _rPlatform tmpUnpack

  -- the subdir of the archive where we do the work
  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
@@ -637,6 +644,8 @@ setGHC :: ( MonadReader AppState m
          , MonadFail m
          , MonadIO m
          , MonadCatch m
+          , MonadMask m
+          , MonadUnliftIO m
          )
       => GHCTargetVersion
       -> SetGHC
@@ -678,10 +687,7 @@ setGHC ver sghc = do
      let fullF = binDir </> targetFile  <> exeExt
          fileWithExt = file <> exeExt
      destL <- lift $ ghcLinkDestination fileWithExt ver
-      lift $ $(logDebug) [i|rm -f #{fullF}|]
-      liftIO $ hideError doesNotExistErrorType $ removeFile fullF
-      lift $ $(logDebug) [i|ln -s #{destL} #{fullF}|]
-      liftIO $ createFileLink destL fullF
+      lift $ createLink destL fullF

  -- create symlink for share dir
  when (isNothing . _tvTarget $ ver) $ lift $ symlinkShareDir ghcdir verS
@@ -705,15 +711,29 @@ setGHC ver sghc = do
          let fullF   = destdir </> sharedir
          let targetF = "." </> "ghc" </> ver' </> sharedir
          $(logDebug) [i|rm -f #{fullF}|]
-          liftIO $ hideError doesNotExistErrorType $ removeFile fullF
+          liftIO $ hideError doesNotExistErrorType $ removeDirectoryLink fullF
          $(logDebug) [i|ln -s #{targetF} #{fullF}|]
-          liftIO $ createDirectoryLink targetF fullF
+          liftIO
+#if defined(IS_WINDOWS)
+            -- On windows we need to be more permissive
+            -- in case symlinks can't be created, be just
+            -- give up here. This symlink isn't strictly necessary.
+            $ hideError permissionErrorType
+            $ hideError illegalOperationErrorType
+#endif
+            $ createDirectoryLink targetF fullF
      _ -> pure ()



 -- | Set the @~\/.ghcup\/bin\/cabal@ symlink.
-setCabal :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+setCabal :: ( MonadMask m
+            , MonadReader AppState m
+            , MonadLogger m
+            , MonadThrow m
+            , MonadFail m
+            , MonadIO m
+            , MonadUnliftIO m)
         => Version
         -> Excepts '[NotInstalled] m ()
 setCabal ver = do
@@ -729,15 +749,9 @@ setCabal ver = do

  let cabalbin = binDir </> "cabal" <> exeExt

-  -- delete old file (may be binary or symlink)
-  lift $ $(logDebug) [i|rm -f #{cabalbin}|]
-  liftIO $ hideError doesNotExistErrorType $ removeFile
-    cabalbin
-
-  -- create symlink
+  -- create link
  let destL = targetFile
-  lift $ $(logDebug) [i|ln -s #{destL} #{cabalbin}|]
-  liftIO $ createFileLink destL cabalbin
+  lift $ createLink destL cabalbin

  pure ()

@@ -751,6 +765,8 @@ setHLS :: ( MonadCatch m
          , MonadThrow m
          , MonadFail m
          , MonadIO m
+          , MonadMask m
+          , MonadUnliftIO m
          )
       => Version
       -> Excepts '[NotInstalled] m ()
@@ -763,7 +779,7 @@ setHLS ver = do
  oldSyms <- lift hlsSymlinks
  forM_ oldSyms $ \f -> do
    lift $ $(logDebug) [i|rm #{binDir </> f}|]
-    liftIO $ removeFile (binDir </> f)
+    liftIO $ rmLink (binDir </> f)

  -- set haskell-language-server-<ghcver> symlinks
  bins <- lift $ hlsServerBinaries ver
@@ -772,28 +788,26 @@ setHLS ver = do
  forM_ bins $ \f -> do
    let destL = f
    let target = (<> exeExt) . head . splitOn "~" $ f
-
-    lift $ $(logDebug) [i|rm -f #{binDir </> target}|]
-    liftIO $ hideError doesNotExistErrorType $ removeFile (binDir </> target)
-
-    lift $ $(logDebug) [i|ln -s #{destL} #{binDir </> target}|]
-    liftIO $ createFileLink destL (binDir </> target)
+    lift $ createLink destL (binDir </> target)

  -- set haskell-language-server-wrapper symlink
  let destL = "haskell-language-server-wrapper-" <> T.unpack (prettyVer ver) <> exeExt
  let wrapper = binDir </> "haskell-language-server-wrapper" <> exeExt

-  lift $ $(logDebug) [i|rm -f #{wrapper}|]
-  liftIO $ hideError doesNotExistErrorType $ removeFile wrapper
-
-  lift $ $(logDebug) [i|ln -s #{destL} #{wrapper}|]
-  liftIO $ createFileLink destL wrapper
+  lift $ createLink destL wrapper

  pure ()


 -- | Set the @~\/.ghcup\/bin\/stack@ symlink.
-setStack :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+setStack :: ( MonadMask m
+            , MonadReader AppState m
+            , MonadLogger m
+            , MonadThrow m
+            , MonadFail m
+            , MonadIO m
+            , MonadUnliftIO m
+            )
         => Version
         -> Excepts '[NotInstalled] m ()
 setStack ver = do
@@ -809,14 +823,7 @@ setStack ver = do

  let stackbin = binDir </> "stack" <> exeExt

-  -- delete old file (may be binary or symlink)
-  lift $ $(logDebug) [i|rm -f #{stackbin}|]
-  liftIO $ hideError doesNotExistErrorType $ removeFile
-    stackbin
-
-  -- create symlink
-  lift $ $(logDebug) [i|ln -s #{targetFile} #{stackbin}|]
-  liftIO $ createFileLink targetFile stackbin
+  lift $ createLink targetFile stackbin

  pure ()

@@ -865,12 +872,10 @@ listVersions :: ( MonadCatch m
                , MonadIO m
                , MonadReader AppState m
                )
-             => GHCupDownloads
-             -> Maybe Tool
+             => Maybe Tool
             -> Maybe ListCriteria
-             -> PlatformRequest
             -> m [ListResult]
-listVersions av lt' criteria pfreq = do
+listVersions lt' criteria = do
  -- some annoying work to avoid too much repeated IO
  cSet <- cabalSet
  cabals <- getInstalledCabals' cSet
@@ -884,8 +889,9 @@ listVersions av lt' criteria pfreq = do
  go lt cSet cabals hlsSet' hlses sSet stacks = do
    case lt of
      Just t -> do
+        AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
        -- get versions from GHCupDownloads
-        let avTools = availableToolVersions av t
+        let avTools = availableToolVersions dls t
        lr <- filter' <$> forM (Map.toList avTools) (toListResult t cSet cabals hlsSet' hlses sSet stacks)

        case t of
@@ -1047,67 +1053,71 @@ listVersions av lt' criteria pfreq = do
               -> [Either FilePath Version]
               -> (Version, [Tag])
               -> m ListResult
-  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, tags) = case t of
-    GHC -> do
-      let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq av
-      let tver = mkTVer v
-      lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
-      lInstalled <- ghcInstalled tver
-      fromSrc    <- ghcSrcInstalled tver
-      hlsPowered <- fmap (elem v) hlsGHCVersions
-      pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
-    Cabal -> do
-      let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq av
-      let lSet = cSet == Just v
-      let lInstalled = elem v $ rights cabals
-      pure ListResult { lVer    = v
-                      , lCross  = Nothing
-                      , lTag    = tags
-                      , lTool   = t
-                      , fromSrc = False
-                      , lStray  = False
-                      , hlsPowered = False
-                      , ..
-                      }
-    GHCup -> do
-      let lSet       = prettyPVP ghcUpVer == prettyVer v
-      let lInstalled = lSet
-      pure ListResult { lVer    = v
-                      , lTag    = tags
-                      , lCross  = Nothing
-                      , lTool   = t
-                      , fromSrc = False
-                      , lStray  = False
-                      , lNoBindist = False
-                      , hlsPowered = False
-                      , ..
-                      }
-    HLS -> do
-      let lNoBindist = isLeft $ getDownloadInfo HLS v pfreq av
-      let lSet = hlsSet' == Just v
-      let lInstalled = elem v $ rights hlses
-      pure ListResult { lVer    = v
-                      , lCross  = Nothing
-                      , lTag    = tags
-                      , lTool   = t
-                      , fromSrc = False
-                      , lStray  = False
-                      , hlsPowered = False
-                      , ..
-                      }
-    Stack -> do
-      let lNoBindist = isLeft $ getDownloadInfo Stack v pfreq av
-      let lSet = stackSet' == Just v
-      let lInstalled = elem v $ rights stacks
-      pure ListResult { lVer    = v
-                      , lCross  = Nothing
-                      , lTag    = tags
-                      , lTool   = t
-                      , fromSrc = False
-                      , lStray  = False
-                      , hlsPowered = False
-                      , ..
-                      }
+  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, tags) = do
+    AppState { pfreq
+             , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+    case t of
+      GHC -> do
+        let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq dls
+        let tver = mkTVer v
+        lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
+        lInstalled <- ghcInstalled tver
+        fromSrc    <- ghcSrcInstalled tver
+        hlsPowered <- fmap (elem v) hlsGHCVersions
+        pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
+      Cabal -> do
+        let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq dls
+        let lSet = cSet == Just v
+        let lInstalled = elem v $ rights cabals
+        pure ListResult { lVer    = v
+                        , lCross  = Nothing
+                        , lTag    = tags
+                        , lTool   = t
+                        , fromSrc = False
+                        , lStray  = False
+                        , hlsPowered = False
+                        , ..
+                        }
+      GHCup -> do
+        let lSet       = prettyPVP ghcUpVer == prettyVer v
+        let lInstalled = lSet
+        pure ListResult { lVer    = v
+                        , lTag    = tags
+                        , lCross  = Nothing
+                        , lTool   = t
+                        , fromSrc = False
+                        , lStray  = False
+                        , lNoBindist = False
+                        , hlsPowered = False
+                        , ..
+                        }
+      HLS -> do
+        let lNoBindist = isLeft $ getDownloadInfo HLS v pfreq dls
+        let lSet = hlsSet' == Just v
+        let lInstalled = elem v $ rights hlses
+        pure ListResult { lVer    = v
+                        , lCross  = Nothing
+                        , lTag    = tags
+                        , lTool   = t
+                        , fromSrc = False
+                        , lStray  = False
+                        , hlsPowered = False
+                        , ..
+                        }
+      Stack -> do
+        let lNoBindist = isLeft $ getDownloadInfo Stack v pfreq dls
+        let lSet = stackSet' == Just v
+        let lInstalled = elem v $ rights stacks
+        pure ListResult { lVer    = v
+                        , lCross  = Nothing
+                        , lTag    = tags
+                        , lTool   = t
+                        , fromSrc = False
+                        , lStray  = False
+                        , hlsPowered = False
+                        , ..
+                        }


  filter' :: [ListResult] -> [ListResult]
@@ -1134,6 +1144,8 @@ rmGHCVer :: ( MonadReader AppState m
            , MonadIO m
            , MonadFail m
            , MonadCatch m
+            , MonadMask m
+            , MonadUnliftIO m
            )
         => GHCTargetVersion
         -> Excepts '[NotInstalled] m ()
@@ -1157,7 +1169,7 @@ rmGHCVer ver = do
  -- then fix them (e.g. with an earlier version)

  lift $ $(logInfo) [i|Removing directory recursively: #{dir}|]
-  liftIO $ removeDirectoryRecursive dir
+  liftIO $ rmPath dir

  v' <-
    handle
@@ -1171,12 +1183,20 @@ rmGHCVer ver = do

  liftIO
    $ hideError doesNotExistErrorType
-    $ removeFile (baseDir </> "share")
+    $ rmFile (baseDir </> "share")


 -- | Delete a cabal version. Will try to fix the @cabal@ symlink
 -- after removal (e.g. setting it to an older version).
-rmCabalVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmCabalVer :: ( MonadMask m
+              , MonadReader AppState m
+              , MonadThrow m
+              , MonadLogger m
+              , MonadIO m
+              , MonadFail m
+              , MonadCatch m
+              , MonadUnliftIO m
+              )
           => Version
           -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
@@ -1187,19 +1207,26 @@ rmCabalVer ver = do
  AppState {dirs = Dirs {..}} <- lift ask

  let cabalFile = "cabal-" <> T.unpack (prettyVer ver) <> exeExt
-  liftIO $ hideError doesNotExistErrorType $ removeFile (binDir </> cabalFile)
+  liftIO $ hideError doesNotExistErrorType $ rmFile (binDir </> cabalFile)

  when (Just ver == cSet) $ do
    cVers <- lift $ fmap rights getInstalledCabals
    case headMay . reverse . sort $ cVers of
      Just latestver -> setCabal latestver
-      Nothing        -> liftIO $ hideError doesNotExistErrorType $ removeFile
-        (binDir </> "cabal" <> exeExt)
+      Nothing        -> liftIO $ rmLink (binDir </> "cabal" <> exeExt)


 -- | Delete a hls version. Will try to fix the hls symlinks
 -- after removal (e.g. setting it to an older version).
-rmHLSVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmHLSVer :: ( MonadMask m
+            , MonadReader AppState m
+            , MonadThrow m
+            , MonadLogger m
+            , MonadIO m
+            , MonadFail m
+            , MonadCatch m
+            , MonadUnliftIO m
+            )
         => Version
         -> Excepts '[NotInstalled] m ()
 rmHLSVer ver = do
@@ -1210,15 +1237,15 @@ rmHLSVer ver = do
  AppState {dirs = Dirs {..}} <- lift ask

  bins <- lift $ hlsAllBinaries ver
-  forM_ bins $ \f -> liftIO $ removeFile (binDir </> f)
+  forM_ bins $ \f -> liftIO $ rmFile (binDir </> f)

  when (Just ver == isHlsSet) $ do
    -- delete all set symlinks
    oldSyms <- lift hlsSymlinks
    forM_ oldSyms $ \f -> do
-      let fullF = binDir </> f <> exeExt
+      let fullF = binDir </> f
      lift $ $(logDebug) [i|rm #{fullF}|]
-      liftIO $ removeFile fullF
+      liftIO $ rmLink fullF
    -- set latest hls
    hlsVers <- lift $ fmap rights getInstalledHLSs
    case headMay . reverse . sort $ hlsVers of
@@ -1228,7 +1255,15 @@ rmHLSVer ver = do

 -- | Delete a stack version. Will try to fix the @stack@ symlink
 -- after removal (e.g. setting it to an older version).
-rmStackVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmStackVer :: ( MonadMask m
+              , MonadReader AppState m
+              , MonadThrow m
+              , MonadLogger m
+              , MonadIO m
+              , MonadFail m
+              , MonadCatch m
+              , MonadUnliftIO m
+              )
           => Version
           -> Excepts '[NotInstalled] m ()
 rmStackVer ver = do
@@ -1239,14 +1274,13 @@ rmStackVer ver = do
  AppState {dirs = Dirs {..}} <- lift ask

  let stackFile = "stack-" <> T.unpack (prettyVer ver) <> exeExt
-  liftIO $ hideError doesNotExistErrorType $ removeFile (binDir </> stackFile)
+  liftIO $ hideError doesNotExistErrorType $ rmFile (binDir </> stackFile)

  when (Just ver == sSet) $ do
    sVers <- lift $ fmap rights getInstalledStacks
    case headMay . reverse . sort $ sVers of
      Just latestver -> setStack latestver
-      Nothing        -> liftIO $ hideError doesNotExistErrorType $ removeFile
-        (binDir </> "stack" <> exeExt)
+      Nothing        -> liftIO $ rmLink (binDir </> "stack" <> exeExt)



@@ -1255,7 +1289,7 @@ rmStackVer ver = do
    ------------------


-getDebugInfo :: (MonadReader AppState m, MonadLogger m, MonadCatch m, MonadIO m)
+getDebugInfo :: (Alternative m, MonadFail m, MonadReader AppState m, MonadLogger m, MonadCatch m, MonadIO m)
             => Excepts
                  '[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
                  m
@@ -1289,14 +1323,12 @@ compileGHC :: ( MonadMask m
              , MonadUnliftIO m
              , MonadFail m
              )
-           => GHCupDownloads
-           -> Either GHCTargetVersion GitBranch          -- ^ version to install
+           => Either GHCTargetVersion GitBranch          -- ^ version to install
           -> Either Version FilePath  -- ^ version to bootstrap with
           -> Maybe Int                  -- ^ jobs
           -> Maybe FilePath           -- ^ build config
           -> Maybe FilePath           -- ^ patch directory
           -> [Text]                     -- ^ additional args to ./configure
-           -> PlatformRequest
           -> Excepts
                '[ AlreadyInstalled
                 , BuildFailed
@@ -1315,8 +1347,12 @@ compileGHC :: ( MonadMask m
                 ]
                m
                GHCTargetVersion
-compileGHC dls targetGhc bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformRequest{..}
+compileGHC targetGhc bstrap jobs mbuildConfig patchdir aargs
  = do
+    AppState { pfreq = PlatformRequest {..}
+             , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }
+             , settings
+             , dirs } <- lift ask
    (workdir, tmpUnpack, tver) <- case targetGhc of
      -- unpack from version tarball
      Left tver -> do
@@ -1326,12 +1362,12 @@ compileGHC dls targetGhc bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformR
        dlInfo <-
          preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
            ?? NoDownload
-        dl        <- liftE $ downloadCached dlInfo Nothing
+        dl        <- liftE $ downloadCached settings dirs dlInfo Nothing

        -- unpack
        tmpUnpack <- lift mkGhcupTmpDir
        liftE $ unpackToDir tmpUnpack dl
-        void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+        void $ lift $ darwinNotarization _rPlatform tmpUnpack

        workdir <- maybe (pure tmpUnpack)
                         (liftE . intoSubdir tmpUnpack)
@@ -1365,13 +1401,13 @@ compileGHC dls targetGhc bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformR
          lEM $ git [ "submodule", "update", "--init", "--depth", "1" ]
          lEM $ execLogged "sh" ["./boot"] (Just tmpUnpack) "ghc-bootstrap" Nothing
          lEM $ execLogged "sh" ["./configure"] (Just tmpUnpack) "ghc-bootstrap" Nothing
-          CapturedProcess {..} <- liftIO $ makeOut
+          CapturedProcess {..} <- lift $ makeOut
            ["show!", "--quiet", "VALUE=ProjectVersion" ] (Just tmpUnpack)
          case _exitCode of
            ExitSuccess -> throwEither . MP.parse ghcProjectVersion "" . decUTF8Safe' $ _stdOut
            ExitFailure c -> fail ("Could not figure out GHC project version. Exit code was: " <> show c <> ". Error was: " <> T.unpack (decUTF8Safe' _stdErr))

-        void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+        void $ lift $ darwinNotarization _rPlatform tmpUnpack
        lift $ $(logInfo) [i|Git version #{ref} corresponds to GHC version #{prettyVer tver}|]

        pure (tmpUnpack, tmpUnpack, GHCTargetVersion Nothing tver)
@@ -1388,7 +1424,7 @@ compileGHC dls targetGhc bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformR

    bghc <- case bstrap of
      Right g    -> pure $ Right g
-      Left  bver -> pure $ Left ("ghc-" <> (T.unpack . prettyVer $ bver))
+      Left  bver -> pure $ Left ("ghc-" <> (T.unpack . prettyVer $ bver) <> exeExt)

    (bindist, bmk) <- liftE $ runBuildAction
      tmpUnpack
@@ -1406,7 +1442,6 @@ compileGHC dls targetGhc bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformR
                             (Just $ RegexDir "ghc-.*")
                             ghcdir
                             (tver ^. tvVersion)
-                             pfreq

    liftIO $ B.writeFile (ghcdir </> ghcUpSrcBuiltFile) bmk

@@ -1451,7 +1486,7 @@ HADDOCK_DOCS = YES|]
    lift $ $(logInfo) [i|configuring build|]
    liftE checkBuildConfig

-    AppState { dirs = Dirs {..} } <- lift ask
+    AppState { dirs = Dirs {..}, pfreq } <- lift ask

    forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir

@@ -1468,6 +1503,9 @@ HADDOCK_DOCS = YES|]
            ("./configure" :  maybe mempty
                      (\x -> ["--target=" <> T.unpack x])
                      (_tvTarget tver)
+#if defined(IS_WINDOWS)
+            ++ ["--enable-tarballs-autodownload"]
+#endif
            ++ fmap T.unpack aargs
            )
            (Just workdir)
@@ -1481,6 +1519,9 @@ HADDOCK_DOCS = YES|]
          ++ maybe mempty
                   (\x -> ["--target=" <> T.unpack x])
                   (_tvTarget tver)
+#if defined(IS_WINDOWS)
+            ++ ["--enable-tarballs-autodownload"]
+#endif
          ++ fmap T.unpack aargs
          )
          (Just workdir)
@@ -1516,7 +1557,7 @@ HADDOCK_DOCS = YES|]
      . SHA256.hashlazy
      $ c
    cTime <- liftIO getCurrentTime
-    let tarName = [i|ghc-#{tVerToText tver}-#{pfReqToString pfreq}-#{iso8601Show cTime}-#{cDigest}.tar#{takeExtension tar}|]
+    let tarName = makeValid [i|ghc-#{tVerToText tver}-#{pfReqToString pfreq}-#{iso8601Show cTime}-#{cDigest}.tar#{takeExtension tar}|]
    let tarPath = cacheDir </> tarName
    handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
                                                             tarPath
@@ -1567,11 +1608,9 @@ upgradeGHCup :: ( MonadMask m
                , MonadIO m
                , MonadUnliftIO m
                )
-             => GHCupDownloads
-             -> Maybe FilePath    -- ^ full file destination to write ghcup into
+             => Maybe FilePath    -- ^ full file destination to write ghcup into
             -> Bool              -- ^ whether to force update regardless
                                  --   of currently installed version
-             -> PlatformRequest
             -> Excepts
                  '[ CopyError
                   , DigestError
@@ -1581,21 +1620,24 @@ upgradeGHCup :: ( MonadMask m
                   ]
                  m
                  Version
-upgradeGHCup dls mtarget force pfreq = do
-  AppState {dirs = Dirs {..}} <- lift ask
+upgradeGHCup mtarget force = do
+  AppState { dirs = Dirs {..}
+           , pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }
+           , settings } <- lift ask
  lift $ $(logInfo) [i|Upgrading GHCup...|]
  let latestVer = fromJust $ fst <$> getLatest dls GHCup
  when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
  dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
  tmp   <- lift withGHCupTmpDir
  let fn = "ghcup" <> exeExt
-  p <- liftE $ download dli tmp (Just fn)
+  p <- liftE $ download settings dli tmp (Just fn)
  let destDir = takeDirectory destFile
      destFile = fromMaybe (binDir </> fn) mtarget
  lift $ $(logDebug) [i|mkdir -p #{destDir}|]
  liftIO $ createDirRecursive' destDir
  lift $ $(logDebug) [i|rm -f #{destFile}|]
-  liftIO $ hideError NoSuchThing $ removeFile destFile
+  liftIO $ hideError NoSuchThing $ rmFile destFile
  lift $ $(logDebug) [i|cp #{p} #{destFile}|]
  handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
                                                           destFile
@@ -1624,6 +1666,8 @@ postGHCInstall :: ( MonadReader AppState m
                  , MonadFail m
                  , MonadIO m
                  , MonadCatch m
+                  , MonadMask m
+                  , MonadUnliftIO m
                  )
               => GHCTargetVersion
               -> Excepts '[NotInstalled] m ()
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -36,7 +36,7 @@ import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
-import           GHCup.Utils
+import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
 import           GHCup.Utils.Prelude
 import           GHCup.Version
@@ -53,8 +53,8 @@ import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
 import           Data.Aeson
 import           Data.Bifunctor
-#if defined(INTERNAL_DOWNLOADER)
 import           Data.ByteString                ( ByteString )
+#if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( CI )
 #endif
 import           Data.List.Extra
@@ -66,6 +66,7 @@ import           Data.Time.Clock.POSIX
 import           Data.Time.Format
 #endif
 import           Data.Versions
+import           Data.Word8
 import           GHC.IO.Exception
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@@ -80,6 +81,7 @@ import           System.IO.Error
 import           URI.ByteString

 import qualified Crypto.Hash.SHA256            as SHA256
+import qualified Data.ByteString               as B
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Map.Strict               as M
@@ -110,26 +112,26 @@ getDownloadsF :: ( FromJSONKey Tool
                 , MonadLogger m
                 , MonadThrow m
                 , MonadFail m
-                 , MonadReader AppState m
                 )
-              => URLSource
+              => Settings
+              -> Dirs
              -> Excepts
                   '[JSONError , DownloadFailed , FileDoesNotExistError]
                   m
                   GHCupInfo
-getDownloadsF urlSource = do
+getDownloadsF settings@Settings{ urlSource } dirs = do
  case urlSource of
-    GHCupURL -> liftE getBase
+    GHCupURL -> liftE $ getBase dirs settings
    (OwnSource url) -> do
-      bs <- reThrowAll DownloadFailed $ downloadBS url
+      bs <- reThrowAll DownloadFailed $ downloadBS (downloader settings) url
      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
    (OwnSpec av) -> pure av
    (AddSource (Left ext)) -> do
-      base <- liftE getBase
+      base <- liftE $ getBase dirs settings
      pure (mergeGhcupInfo base ext)
    (AddSource (Right uri)) -> do
-      base <- liftE getBase
-      bsExt <- reThrowAll DownloadFailed $ downloadBS uri
+      base <- liftE $ getBase dirs settings
+      bsExt <- reThrowAll DownloadFailed $ downloadBS (downloader settings) uri
      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
      pure (mergeGhcupInfo base ext)

@@ -138,18 +140,19 @@ getDownloadsF urlSource = do
  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                 -> GHCupInfo -- ^ extension overwriting the base
                 -> GHCupInfo
-  mergeGhcupInfo (GHCupInfo tr base) (GHCupInfo _ ext) =
-    let new = M.mapWithKey (\k a -> case M.lookup k ext of
+  mergeGhcupInfo (GHCupInfo tr base base2) (GHCupInfo _ ext ext2) =
+    let newDownloads = M.mapWithKey (\k a -> case M.lookup k ext of
                                        Just a' -> M.union a' a
                                        Nothing -> a
-                           ) base
-    in GHCupInfo tr new
+                                    ) base
+        newGlobalTools = M.union base2 ext2
+    in GHCupInfo tr newDownloads newGlobalTools


-readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
-readFromCache = do
-  AppState {dirs = Dirs {..}} <- lift ask
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m)
+              => Dirs
+              -> Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+readFromCache Dirs {..} = do
  lift $ $(logWarn)
    [i|Could not get download info, trying cached version (this may not be recent!)|]
  let path = view pathL' ghcupURL
@@ -162,12 +165,14 @@ readFromCache = do
  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)


-getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-getBase =
-  handleIO (\_ -> readFromCache)
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m)
+        => Dirs
+        -> Settings
+        -> Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase dirs@Dirs{..} Settings{ downloader }  =
+  handleIO (\_ -> readFromCache dirs)
  $ catchE @_ @'[JSONError, FileDoesNotExistError]
-      (\(DownloadFailed _) -> readFromCache)
+      (\(DownloadFailed _) -> readFromCache dirs)
  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
    where
@@ -185,7 +190,6 @@ getBase =
             , MonadIO m1
             , MonadFail m1
             , MonadLogger m1
-             , MonadReader AppState m1
             )
          => URI
          -> Excepts
@@ -200,7 +204,6 @@ getBase =
               m1
               L.ByteString
  smartDl uri' = do
-    AppState {dirs = Dirs {..}} <- lift ask
    let path = view pathL' uri'
    let json_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
    e         <- liftIO $ doesFileExist json_file
@@ -235,12 +238,12 @@ getBase =

   where
    dlWithMod modTime json_file = do
-      bs <- liftE $ downloadBS uri'
+      bs <- liftE $ downloadBS downloader uri'
      liftIO $ writeFileWithModTime modTime json_file bs
      pure bs
    dlWithoutMod json_file = do
-      bs <- liftE $ downloadBS uri'
-      liftIO $ hideError doesNotExistErrorType $ removeFile json_file
+      bs <- liftE $ downloadBS downloader uri'
+      liftIO $ hideError doesNotExistErrorType $ rmFile json_file
      liftIO $ L.writeFile json_file bs
      liftIO $ setModificationTime json_file (posixSecondsToUTCTime (fromIntegral @Int 0))
      pure bs
@@ -320,16 +323,16 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
 --
 -- The file must not exist.
 download :: ( MonadMask m
-            , MonadReader AppState m
            , MonadThrow m
            , MonadLogger m
            , MonadIO m
            )
-         => DownloadInfo
+         => Settings
+         -> DownloadInfo
         -> FilePath          -- ^ destination dir
         -> Maybe FilePath    -- ^ optional filename
         -> Excepts '[DigestError , DownloadFailed] m FilePath
-download dli dest mfn
+download settings@Settings{ downloader } dli dest mfn
  | scheme == "https" = dl
  | scheme == "http"  = dl
  | scheme == "file"  = cp
@@ -354,20 +357,20 @@ download dli dest mfn

    -- download
    flip onException
-         (liftIO $ hideError doesNotExistErrorType $ removeFile destFile)
+         (liftIO $ hideError doesNotExistErrorType $ rmFile destFile)
     $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
          (\e ->
-            liftIO (hideError doesNotExistErrorType $ removeFile destFile)
+            liftIO (hideError doesNotExistErrorType $ rmFile destFile)
              >> (throwE . DownloadFailed $ e)
          ) $ do
-              lift getDownloader >>= \case
+              case downloader of
                Curl -> do
                  o' <- liftIO getCurlOpts
-                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "curl" 
+                  liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
                    (o' ++ ["-fL", "-o", destFile, (T.unpack . decUTF8Safe) $ serializeURIRef' $ view dlUri dli]) Nothing Nothing
                Wget -> do
                  o' <- liftIO getWgetOpts
-                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "wget" 
+                  liftE $ lEM @_ @'[ProcessError] $ exec "wget" 
                    (o' ++ ["-O", destFile , (T.unpack . decUTF8Safe) $ serializeURIRef' $ view dlUri dli]) Nothing Nothing
 #if defined(INTERNAL_DOWNLOADER)
                Internal -> do
@@ -375,7 +378,7 @@ download dli dest mfn
                  liftE $ downloadToFile https host fullPath port destFile
 #endif

-    liftE $ checkDigest dli destFile
+    liftE $ checkDigest settings dli destFile
    pure destFile

  -- Manage to find a file we can write the body into.
@@ -393,27 +396,40 @@ downloadCached :: ( MonadMask m
                  , MonadLogger m
                  , MonadIO m
                  , MonadUnliftIO m
-                  , MonadReader AppState m
                  )
-               => DownloadInfo
+               => Settings
+               -> Dirs
+               -> DownloadInfo
               -> Maybe FilePath  -- ^ optional filename
               -> Excepts '[DigestError , DownloadFailed] m FilePath
-downloadCached dli mfn = do
-  cache <- lift getCache
+downloadCached settings@Settings{ cache } dirs dli mfn = do
  case cache of
-    True -> do
-      AppState {dirs = Dirs {..}} <- lift ask
-      let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
-      let cachfile = cacheDir </> fn
-      fileExists <- liftIO $ doesFileExist cachfile
-      if
-        | fileExists -> do
-          liftE $ checkDigest dli cachfile
-          pure cachfile
-        | otherwise -> liftE $ download dli cacheDir mfn
+    True -> downloadCached' settings dirs dli mfn
    False -> do
      tmp <- lift withGHCupTmpDir
-      liftE $ download dli tmp mfn
+      liftE $ download settings dli tmp mfn
+
+
+downloadCached' :: ( MonadMask m
+                   , MonadThrow m
+                   , MonadLogger m
+                   , MonadIO m
+                   , MonadUnliftIO m
+                   )
+                => Settings
+                -> Dirs
+                -> DownloadInfo
+                -> Maybe FilePath  -- ^ optional filename
+                -> Excepts '[DigestError , DownloadFailed] m FilePath
+downloadCached' settings Dirs{..} dli mfn = do
+  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
+  let cachfile = cacheDir </> fn
+  fileExists <- liftIO $ doesFileExist cachfile
+  if
+    | fileExists -> do
+      liftE $ checkDigest settings dli cachfile
+      pure cachfile
+    | otherwise -> liftE $ download settings dli cacheDir mfn



@@ -426,8 +442,9 @@ downloadCached dli mfn = do


 -- | This is used for downloading the JSON.
-downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
-           => URI
+downloadBS :: (MonadCatch m, MonadIO m, MonadLogger m)
+           => Downloader
+           -> URI
           -> Excepts
                '[ FileDoesNotExistError
                 , HTTPStatusError
@@ -439,7 +456,7 @@ downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
                 ]
                m
                L.ByteString
-downloadBS uri'
+downloadBS downloader uri'
  | scheme == "https"
  = dl True
  | scheme == "http"
@@ -459,12 +476,12 @@ downloadBS uri'
  dl _ = do
 #endif
    lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
-    lift getDownloader >>= \case
+    case downloader of
      Curl -> do
        o' <- liftIO getCurlOpts
        let exe = "curl"
            args = o' ++ ["-sSfL", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
-        liftIO (executeOut exe args Nothing) >>= \case
+        lift (executeOut exe args Nothing) >>= \case
          CapturedProcess ExitSuccess stdout _ -> do
            pure stdout
          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
@@ -472,7 +489,7 @@ downloadBS uri'
        o' <- liftIO getWgetOpts
        let exe = "wget"
            args = o' ++ ["-qO-", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
-        liftIO (executeOut exe args Nothing) >>= \case
+        lift (executeOut exe args Nothing) >>= \case
          CapturedProcess ExitSuccess stdout _ -> do
            pure stdout
          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
@@ -483,12 +500,13 @@ downloadBS uri'
 #endif


-checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader AppState m)
-            => DownloadInfo
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m)
+            => Settings
+            -> DownloadInfo
            -> FilePath
            -> Excepts '[DigestError] m ()
-checkDigest dli file = do
-  verify <- lift ask <&> (not . noVerify . settings)
+checkDigest Settings{ noVerify } dli file = do
+  let verify = not noVerify
  when verify $ do
    let p' = takeFileName file
    lift $ $(logInfo) [i|verifying digest of: #{p'}|]
@@ -513,3 +531,8 @@ getWgetOpts =
    Just r  -> pure $ splitOn " " r
    Nothing -> pure []

+
+urlBaseName :: ByteString  -- ^ the url path (without scheme and host)
+            -> ByteString
+urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
+
--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -57,7 +57,7 @@ import qualified Data.Text.IO                  as T


 -- | Get the full platform request, consisting of architecture, distro, ...
-platformRequest :: (MonadLogger m, MonadCatch m, MonadIO m)
+platformRequest :: (Alternative m, MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
                => Excepts
                     '[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]
                     m
@@ -82,7 +82,7 @@ getArchitecture = case arch of
  what          -> Left (NoCompatibleArch what)


-getPlatform :: (MonadLogger m, MonadCatch m, MonadIO m)
+getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
            => Excepts
                 '[NoCompatiblePlatform, DistroNotFound]
                 m
@@ -112,22 +112,21 @@ getPlatform = do
  pure pfr
 where
  getMajorVersion = T.intercalate "." . take 2 . T.split (== '.')
-  getFreeBSDVersion =
-    liftIO $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
-  getDarwinVersion = liftIO $ fmap _stdOut $ executeOut "sw_vers"
+  getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
+  getDarwinVersion = lift $ fmap _stdOut $ executeOut "sw_vers"
                                                        ["-productVersion"]
                                                        Nothing


-getLinuxDistro :: (MonadCatch m, MonadIO m)
+getLinuxDistro :: (Alternative m, MonadCatch m, MonadIO m, MonadFail m)
               => Excepts '[DistroNotFound] m (LinuxDistro, Maybe Versioning)
 getLinuxDistro = do
  -- TODO: don't do alternative on IO, because it hides bugs
-  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ liftIO $ asum
-    [ try_os_release
+  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ lift $ asum
+    [ liftIO try_os_release
    , try_lsb_release_cmd
-    , try_redhat_release
-    , try_debian_version
+    , liftIO try_redhat_release
+    , liftIO try_debian_version
    ]
  let parsedVer = ver >>= either (const Nothing) Just . versioning
      distro    = if
@@ -163,9 +162,10 @@ getLinuxDistro = do
      fmap osRelease <$> parseOsRelease
    pure (T.pack name, fmap T.pack version_id)

-  try_lsb_release_cmd :: IO (Text, Maybe Text)
+  try_lsb_release_cmd :: (MonadFail m, MonadIO m)
+                      => m (Text, Maybe Text)
  try_lsb_release_cmd = do
-    (Just _) <- findExecutable lsb_release_cmd
+    (Just _) <- liftIO $ findExecutable lsb_release_cmd
    name     <- fmap _stdOut $ executeOut lsb_release_cmd ["-si"] Nothing
    ver      <- fmap _stdOut $ executeOut lsb_release_cmd ["-sr"] Nothing
    pure (decUTF8Safe' name, Just $ decUTF8Safe' ver)
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -20,16 +20,20 @@ module GHCup.Types
  )
  where

+import           Control.Applicative
+import           Control.Monad.Logger
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
 import           Data.Text                      ( Text )
 import           Data.Versions
+import           Haskus.Utils.Variant.Excepts
 import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
 #if defined(BRICK)
 import           Graphics.Vty                   ( Key(..) )
 #endif

+import qualified Control.Monad.Trans.Class     as Trans
 import qualified Data.Text                     as T
 import qualified GHC.Generics                  as GHC

@@ -52,6 +56,7 @@ data Key = KEsc  | KChar Char | KBS | KEnter
 data GHCupInfo = GHCupInfo
  { _toolRequirements :: ToolRequirements
  , _ghcupDownloads   :: GHCupDownloads
+  , _globalTools      :: Map GlobalTool DownloadInfo
  }
  deriving (Show, GHC.Generic)

@@ -100,6 +105,9 @@ data Tool = GHC
          | Stack
  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)

+data GlobalTool = ShimGen
+  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
+

 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
@@ -307,6 +315,8 @@ data AppState = AppState
  { settings :: Settings
  , dirs :: Dirs
  , keyBindings :: KeyBindings
+  , ghcupInfo :: GHCupInfo
+  , pfreq :: PlatformRequest
  } deriving (Show)

 data Settings = Settings
@@ -437,3 +447,16 @@ instance Pretty Versioning where

 instance Pretty Version where
  pPrint = text . T.unpack . prettyVer
+
+
+instance (Monad m, Alternative m) => Alternative (LoggingT m) where
+    empty   = Trans.lift empty
+    {-# INLINE empty #-}
+    m <|> n = LoggingT $ \ r -> runLoggingT m r <|> runLoggingT n r
+    {-# INLINE (<|>) #-}
+
+
+instance MonadLogger m => MonadLogger (Excepts e m) where
+  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
+
+
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@@ -44,23 +44,16 @@ import qualified Text.Megaparsec.Char          as MPC

 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Key

 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
@@ -197,6 +190,12 @@ instance ToJSONKey Tool where
 instance FromJSONKey Tool where
  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions

+instance ToJSONKey GlobalTool where
+  toJSONKey = genericToJSONKey defaultJSONKeyOptions
+
+instance FromJSONKey GlobalTool where
+  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions
+
 instance ToJSON TarDir where
  toJSON (RealDir  p) = toJSON p
  toJSON (RegexDir r) = object ["RegexDir" .= r]
@@ -306,3 +305,14 @@ instance FromJSONKey (Maybe VersionRange)  where
    just t = case MP.parse versionRangeP "" t of
      Right x -> pure $ Just x
      Left  e -> fail $ "Failure in (Maybe VersionRange) (FromJSONKey)" <> MP.errorBundlePretty e
+
+
+
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Key
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -26,6 +26,9 @@ module GHCup.Utils
 where


+#if defined(IS_WINDOWS)
+import           GHCup.Download
+#endif
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.Optics
@@ -48,6 +51,11 @@ import           Control.Monad.Fail             ( MonadFail )
 #endif
 import           Control.Monad.Logger
 import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+                                         hiding ( throwM )
+#if defined(IS_WINDOWS)
+import           Data.Bits
+#endif
 import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
@@ -58,7 +66,6 @@ import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Data.Word8
 import           GHC.IO.Exception
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@@ -66,7 +73,11 @@ import           Safe
 import           System.Directory      hiding   ( findFiles )
 import           System.FilePath
 import           System.IO.Error
-import           System.IO.Unsafe               ( unsafeInterleaveIO )
+#if defined(IS_WINDOWS)
+import           System.Win32.Console
+import           System.Win32.File     hiding ( copyFile )
+import           System.Win32.Types
+#endif
 import           Text.Regex.Posix
 import           URI.ByteString

@@ -121,7 +132,7 @@ rmMinorSymlinks tv@GHCTargetVersion{..} = do
    let f_xyz = f <> "-" <> T.unpack (prettyVer _tvVersion) <> exeExt
    let fullF = binDir </> f_xyz
    lift $ $(logDebug) [i|rm -f #{fullF}|]
-    liftIO $ hideError doesNotExistErrorType $ removeFile fullF
+    liftIO $ hideError doesNotExistErrorType $ rmLink fullF


 -- | Removes the set ghc version for the given target, if any.
@@ -141,11 +152,11 @@ rmPlain target = do
    forM_ files $ \f -> do
      let fullF = binDir </> f <> exeExt
      lift $ $(logDebug) [i|rm -f #{fullF}|]
-      liftIO $ hideError doesNotExistErrorType $ removeFile fullF
+      liftIO $ hideError doesNotExistErrorType $ rmLink fullF
    -- old ghcup
    let hdc_file = binDir </> "haddock-ghc" <> exeExt
    lift $ $(logDebug) [i|rm -f #{hdc_file}|]
-    liftIO $ hideError doesNotExistErrorType $ removeFile hdc_file
+    liftIO $ hideError doesNotExistErrorType $ rmLink hdc_file


 -- | Remove the major GHC symlink, e.g. ghc-8.6.
@@ -168,7 +179,7 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
    let f_xy = f <> "-" <> T.unpack v' <> exeExt
    let fullF = binDir </> f_xy
    lift $ $(logDebug) [i|rm -f #{fullF}|]
-    liftIO $ hideError doesNotExistErrorType $ removeFile fullF
+    liftIO $ hideError doesNotExistErrorType $ rmLink fullF



@@ -205,27 +216,27 @@ ghcSet mtarget = do
  -- link destination is of the form ../ghc/<ver>/bin/ghc
  -- for old ghcup, it is ../ghc/<ver>/bin/ghc-<ver>
  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
-    link <- liftIO $ getSymbolicLinkTarget ghcBin
+    link <- liftIO $ getLinkTarget ghcBin
    Just <$> ghcLinkVersion link
-
-ghcLinkVersion :: MonadThrow m => FilePath -> m GHCTargetVersion
-ghcLinkVersion (T.pack . dropSuffix exeExt -> t) = throwEither $ MP.parse parser "ghcLinkVersion" t
 where
-  parser =
-      (do
-         _    <- parseUntil1 ghcSubPath
-         _    <- ghcSubPath
-         r    <- parseUntil1 pathSep
-         rest <- MP.getInput
-         MP.setInput r
-         x <- ghcTargetVerP
-         MP.setInput rest
-         pure x
-       )
-      <* pathSep
-      <* MP.takeRest
-      <* MP.eof
-  ghcSubPath = pathSep <* MP.chunk "ghc" *> pathSep
+  ghcLinkVersion :: MonadThrow m => FilePath -> m GHCTargetVersion
+  ghcLinkVersion (T.pack . dropSuffix exeExt -> t) = throwEither $ MP.parse parser "ghcLinkVersion" t
+   where
+    parser =
+        (do
+           _    <- parseUntil1 ghcSubPath
+           _    <- ghcSubPath
+           r    <- parseUntil1 pathSep
+           rest <- MP.getInput
+           MP.setInput r
+           x <- ghcTargetVerP
+           MP.setInput rest
+           pure x
+         )
+        <* pathSep
+        <* MP.takeRest
+        <* MP.eof
+    ghcSubPath = pathSep <* MP.chunk "ghc" *> pathSep

 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
@@ -254,7 +265,7 @@ getInstalledCabals' cs = do
  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
-  vs <- forM bins $ \f -> case fmap (version . T.pack . dropSuffix exeExt) . stripPrefix "cabal-" $ f of
+  vs <- forM bins $ \f -> case version . T.pack <$> (stripSuffix exeExt =<< stripPrefix "cabal-" f) of
    Just (Right r) -> pure $ Right r
    Just (Left  _) -> pure $ Left f
    Nothing        -> pure $ Left f
@@ -273,7 +284,7 @@ cabalSet :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadThrow m, Mon
 cabalSet = do
  AppState {dirs = Dirs {..}} <- ask
  let cabalbin = binDir </> "cabal" <> exeExt
-  b        <- handleIO (\_ -> pure False) $ liftIO $ pathIsSymbolicLink cabalbin
+  b        <- handleIO (\_ -> pure False) $ liftIO $ pathIsLink cabalbin
  if
    | b -> do
      handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -281,20 +292,20 @@ cabalSet = do
        if broken
          then pure Nothing
          else do
-            link <- liftIO $ getSymbolicLinkTarget cabalbin
+            link <- liftIO $ getLinkTarget cabalbin
            case linkVersion link of
              Right v -> pure $ Just v
              Left err -> do
                $(logWarn) [i|Failed to parse cabal symlink target with: "#{err}". The symlink #{cabalbin} needs to point to valid cabal binary, such as 'cabal-3.4.0.0'.|]
                pure Nothing
    | otherwise -> do -- legacy behavior
-      mc <- liftIO $ handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
+      mc <- handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
        cabalbin
        ["--numeric-version"]
        Nothing
      fmap join $ forM mc $ \c -> if
        | not (BL.null (_stdOut c)), _exitCode c == ExitSuccess -> do
-          let reportedVer = fst . B.spanEnd (== _lf) . BL.toStrict . _stdOut $ c
+          let reportedVer = fst . B.spanEnd isNewLine . BL.toStrict . _stdOut $ c
          case version $ decUTF8Safe reportedVer of
            Left  e -> throwM e
            Right r -> pure $ Just r
@@ -304,7 +315,7 @@ cabalSet = do
  -- because of:
  --   https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/119
  linkVersion :: MonadThrow m => FilePath -> m Version
-  linkVersion = throwEither . MP.parse parser "" . T.pack . dropSuffix exeExt
+  linkVersion = throwEither . MP.parse parser "linkVersion" . T.pack . dropSuffix exeExt

  parser
    =   MP.try (stripAbsolutePath *> cabalParse)
@@ -338,7 +349,7 @@ getInstalledHLSs = do
    )
  forM bins $ \f ->
    case
-          fmap (version . T.pack . dropSuffix exeExt) . stripPrefix "haskell-language-server-wrapper-" $ f
+          version . T.pack <$> (stripSuffix exeExt =<< stripPrefix "haskell-language-server-wrapper-" f)
      of
        Just (Right r) -> pure $ Right r
        Just (Left  _) -> pure $ Left f
@@ -357,9 +368,7 @@ getInstalledStacks = do
                   ([s|^stack-.*$|] :: ByteString)
    )
  forM bins $ \f ->
-    case
-          fmap (version . T.pack . dropSuffix exeExt) . stripPrefix "stack-" $ f
-      of
+    case version . T.pack <$> (stripSuffix exeExt =<< stripPrefix "stack-" f) of
        Just (Right r) -> pure $ Right r
        Just (Left  _) -> pure $ Left f
        Nothing        -> pure $ Left f
@@ -376,14 +385,27 @@ stackSet = do
    if broken
      then pure Nothing
      else do
-        link <- liftIO $ getSymbolicLinkTarget stackBin
+        link <- liftIO $ getLinkTarget stackBin
        Just <$> linkVersion link
 where
  linkVersion :: MonadThrow m => FilePath -> m Version
  linkVersion = throwEither . MP.parse parser "" . T.pack . dropSuffix exeExt
   where
-    parser =
-      MP.chunk "stack-" *> version'
+    parser
+      =   MP.try (stripAbsolutePath *> cabalParse)
+      <|> MP.try (stripRelativePath *> cabalParse)
+      <|> cabalParse
+    -- parses the version of "stack-2.7.1" -> "2.7.1"
+    cabalParse = MP.chunk "stack-" *> version'
+    -- parses any path component ending with path separator,
+    -- e.g. "foo/"
+    stripPathComponet = parseUntil1 pathSep *> pathSep
+    -- parses an absolute path up until the last path separator,
+    -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
+    stripAbsolutePath = pathSep *> MP.many (MP.try stripPathComponet)
+    -- parses a relative path up until the last path separator,
+    -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
+    stripRelativePath = MP.many (MP.try stripPathComponet)

 -- | Whether the given Stack version is installed.
 stackInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
@@ -410,14 +432,27 @@ hlsSet = do
    if broken
      then pure Nothing
      else do
-        link <- liftIO $ getSymbolicLinkTarget hlsBin
+        link <- liftIO $ getLinkTarget hlsBin
        Just <$> linkVersion link
 where
  linkVersion :: MonadThrow m => FilePath -> m Version
  linkVersion = throwEither . MP.parse parser "" . T.pack . dropSuffix exeExt
   where
-    parser =
-      MP.chunk "haskell-language-server-wrapper-" *> version'
+    parser
+      =   MP.try (stripAbsolutePath *> cabalParse)
+      <|> MP.try (stripRelativePath *> cabalParse)
+      <|> cabalParse
+    -- parses the version of "haskell-language-server-wrapper-1.1.0" -> "1.1.0"
+    cabalParse = MP.chunk "haskell-language-server-wrapper-" *> version'
+    -- parses any path component ending with path separator,
+    -- e.g. "foo/"
+    stripPathComponet = parseUntil1 pathSep *> pathSep
+    -- parses an absolute path up until the last path separator,
+    -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
+    stripAbsolutePath = pathSep *> MP.many (MP.try stripPathComponet)
+    -- parses a relative path up until the last path separator,
+    -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
+    stripRelativePath = MP.many (MP.try stripPathComponet)


 -- | Return the GHC versions the currently selected HLS supports.
@@ -500,7 +535,7 @@ hlsSymlinks = do
    )
  filterM
    ( liftIO
-    . pathIsSymbolicLink
+    . pathIsLink
    . (binDir </>)
    )
    oldSyms
@@ -726,11 +761,6 @@ getDownloader = ask <&> downloader . settings
    -------------


-urlBaseName :: ByteString  -- ^ the url path (without scheme and host)
-            -> ByteString
-urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
-
-
 -- | Get tool files from @~\/.ghcup\/bin\/ghc\/\<ver\>\/bin\/\*@
 -- while ignoring @*-\<ver\>@ symlinks and accounting for cross triple prefix.
 --
@@ -810,19 +840,20 @@ make args workdir = do
  let mymake = if has_gmake then "gmake" else "make"
  execLogged mymake args workdir "ghc-make" Nothing

-makeOut :: [String]
+makeOut :: (MonadReader AppState m, MonadIO m)
+        => [String]
        -> Maybe FilePath
-        -> IO CapturedProcess
+        -> m CapturedProcess
 makeOut args workdir = do
  spaths    <- liftIO getSearchPath
  has_gmake <- isJust <$> liftIO (searchPath spaths "gmake")
  let mymake = if has_gmake then "gmake" else "make"
-  liftIO $ executeOut mymake args workdir
+  executeOut mymake args workdir


 -- | Try to apply patches in order. Fails with 'PatchFailed'
 -- on first failure.
-applyPatches :: (MonadLogger m, MonadIO m)
+applyPatches :: (MonadReader AppState m, MonadLogger m, MonadIO m)
             => FilePath   -- ^ dir containing patches
             -> FilePath   -- ^ dir to apply patches in
             -> Excepts '[PatchFailed] m ()
@@ -831,7 +862,7 @@ applyPatches pdir ddir = do
  forM_ (sort patches) $ \patch' -> do
    lift $ $(logInfo) [i|Applying patch #{patch'}|]
    fmap (either (const Nothing) Just)
-         (liftIO $ exec
+         (exec
           "patch"
           ["-p1", "-i", patch']
           (Just ddir)
@@ -840,7 +871,10 @@ applyPatches pdir ddir = do


 -- | https://gitlab.haskell.org/ghc/ghc/-/issues/17353
-darwinNotarization :: Platform -> FilePath -> IO (Either ProcessError ())
+darwinNotarization :: (MonadReader AppState m, MonadIO m)
+                   => Platform
+                   -> FilePath
+                   -> m (Either ProcessError ())
 darwinNotarization Darwin path = exec
  "xattr"
  ["-r", "-d", "com.apple.quarantine", path]
@@ -869,11 +903,11 @@ runBuildAction bdir instdir action = do
  AppState { settings = Settings {..} } <- lift ask
  let exAction = do
        forM_ instdir $ \dir ->
-          liftIO $ hideError doesNotExistErrorType $ removeDirectoryRecursive dir
+          liftIO $ hideError doesNotExistErrorType $ rmPath dir
        when (keepDirs == Never)
          $ liftIO
          $ hideError doesNotExistErrorType
-          $ removeDirectoryRecursive bdir
+          $ rmPath bdir
  v <-
    flip onException exAction
    $ catchAllE
@@ -882,90 +916,10 @@ runBuildAction bdir instdir action = do
          throwE (BuildFailed bdir es)
        ) action

-  when (keepDirs == Never || keepDirs == Errors) $ liftIO $ removeDirectoryRecursive
-    bdir
+  when (keepDirs == Never || keepDirs == Errors) $ liftIO $ rmPath bdir
  pure v


-- | More permissive version of 'createDirRecursive'. This doesn't
-- error when the destination is a symlink to a directory.
-createDirRecursive' :: FilePath -> IO ()
-createDirRecursive' p =
-  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
-    . createDirectoryIfMissing True
-    $ p
-
- where
-  isSymlinkDir e = do
-    ft <- pathIsSymbolicLink p
-    case ft of
-      True -> do
-        rp <- canonicalizePath p
-        rft <- doesDirectoryExist rp
-        case rft of
-          True -> pure ()
-          _ -> throwIO e
-      _ -> throwIO e
-
-
-- | Recursively copy the contents of one directory to another path.
--
-- This is a rip-off of Cabal library.
-copyDirectoryRecursive :: FilePath -> FilePath -> IO ()
-copyDirectoryRecursive srcDir destDir = do
-  srcFiles <- getDirectoryContentsRecursive srcDir
-  copyFilesWith copyFile destDir [ (srcDir, f)
-                                   | f <- srcFiles ]
-  where
-    -- | Common implementation of 'copyFiles', 'installOrdinaryFiles',
-    -- 'installExecutableFiles' and 'installMaybeExecutableFiles'.
-    copyFilesWith :: (FilePath -> FilePath -> IO ())
-                  -> FilePath -> [(FilePath, FilePath)] -> IO ()
-    copyFilesWith doCopy targetDir srcFiles = do
-
-      -- Create parent directories for everything
-      let dirs = map (targetDir </>) . nub . map (takeDirectory . snd) $ srcFiles
-      traverse_ (createDirectoryIfMissing True) dirs
-
-      -- Copy all the files
-      sequence_ [ let src  = srcBase   </> srcFile
-                      dest = targetDir </> srcFile
-                   in doCopy src dest
-                | (srcBase, srcFile) <- srcFiles ]
-
-    -- | List all the files in a directory and all subdirectories.
-    --
-    -- The order places files in sub-directories after all the files in their
-    -- parent directories. The list is generated lazily so is not well defined if
-    -- the source directory structure changes before the list is used.
-    --
-    getDirectoryContentsRecursive :: FilePath -> IO [FilePath]
-    getDirectoryContentsRecursive topdir = recurseDirectories [""]
-      where
-        recurseDirectories :: [FilePath] -> IO [FilePath]
-        recurseDirectories []         = return []
-        recurseDirectories (dir:dirs) = unsafeInterleaveIO $ do
-          (files, dirs') <- collect [] [] =<< getDirectoryContents (topdir </> dir)
-          files' <- recurseDirectories (dirs' ++ dirs)
-          return (files ++ files')
-
-          where
-            collect files dirs' []              = return (reverse files
-                                                         ,reverse dirs')
-            collect files dirs' (entry:entries) | ignore entry
-                                                = collect files dirs' entries
-            collect files dirs' (entry:entries) = do
-              let dirEntry = dir </> entry
-              isDirectory <- doesDirectoryExist (topdir </> dirEntry)
-              if isDirectory
-                then collect files (dirEntry:dirs') entries
-                else collect (dirEntry:files) dirs' entries
-
-            ignore ['.']      = True
-            ignore ['.', '.'] = True
-            ignore _          = False
-
-
 getVersionInfo :: Version
               -> Tool
               -> GHCupDownloads
@@ -979,15 +933,6 @@ getVersionInfo v' tool =
    )


-- Gathering monoidal values
-traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
-traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
-
-- | Gathering monoidal values
-forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
-forFold = \t -> (`traverseFold` t)
-
-
 -- | The file extension for executables.
 exeExt :: String
 #if defined(IS_WINDOWS)
@@ -996,3 +941,150 @@ exeExt = ".exe"
 exeExt = ""
 #endif

+-- | The file extension for executables.
+exeExt' :: ByteString
+#if defined(IS_WINDOWS)
+exeExt' = ".exe"
+#else
+exeExt' = ""
+#endif
+
+
+-- | Enables ANSI support on windows, does nothing on unix.
+--
+-- Returns 'Left str' on errors and 'Right bool' on success, where
+-- 'bool' markes whether ansi support was already enabled.
+--
+-- This function never crashes.
+--
+-- Rip-off of https://docs.rs/ansi_term/0.12.1/x86_64-pc-windows-msvc/src/ansi_term/windows.rs.html#10-61
+enableAnsiSupport :: IO (Either String Bool)
+#if defined(IS_WINDOWS)
+enableAnsiSupport = handleIO (pure . Left . displayException) $ do
+  -- ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+  -- Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
+  h <- createFile "CONOUT$" (gENERIC_WRITE .|. gENERIC_READ)
+    fILE_SHARE_WRITE Nothing oPEN_EXISTING 0 Nothing
+  when (h == iNVALID_HANDLE_VALUE ) $ fail "invalid handle value"
+
+  -- ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
+  m <- getConsoleMode h
+
+  -- VT processing not already enabled?
+  if ((m .&. eNABLE_VIRTUAL_TERMINAL_PROCESSING) == 0)
+  -- https://docs.microsoft.com/en-us/windows/console/setconsolemode
+  then setConsoleMode h (m .|. eNABLE_VIRTUAL_TERMINAL_PROCESSING)
+    >> pure (Right False)
+  else pure (Right True)
+#else
+enableAnsiSupport = pure (Right True)
+#endif
+
+
+-- | On unix, we can use symlinks, so we just get the
+-- symbolic link target.
+--
+-- On windows, we have to emulate symlinks via shims,
+-- see 'createLink'.
+getLinkTarget :: FilePath -> IO FilePath
+getLinkTarget fp = do
+#if defined(IS_WINDOWS)
+  content <- readFile (dropExtension fp <.> "shim")
+  [p] <- pure . filter ("path = " `isPrefixOf`) . lines $ content
+  pure $ stripNewline $ dropPrefix "path = " p
+#else
+  getSymbolicLinkTarget fp
+#endif
+
+
+-- | Checks whether the path is a link.
+pathIsLink :: FilePath -> IO Bool
+#if defined(IS_WINDOWS)
+pathIsLink fp = doesPathExist (dropExtension fp <.> "shim")
+#else
+pathIsLink = pathIsSymbolicLink
+#endif
+
+
+rmLink :: FilePath -> IO ()
+#if defined(IS_WINDOWS)
+rmLink fp = do
+  hideError doesNotExistErrorType . liftIO . rmFile $ fp
+  hideError doesNotExistErrorType . liftIO . rmFile $ (dropExtension fp <.> "shim")
+#else
+rmLink = hideError doesNotExistErrorType . liftIO . rmFile
+#endif
+
+
+-- | Creates a symbolic link on unix and a fake symlink on windows for
+-- executables, which:
+--     1. is a shim exe
+--     2. has a corresponding .shim file in the same directory that
+--        contains the target
+--
+-- This overwrites previously existing files.
+--
+-- On windows, this requires that 'ensureGlobalTools' was run beforehand.
+createLink :: ( MonadMask m
+              , MonadThrow m
+              , MonadLogger m
+              , MonadIO m
+              , MonadReader AppState m
+              , MonadUnliftIO m
+              , MonadFail m
+              )
+           => FilePath      -- ^ path to the target executable
+           -> FilePath      -- ^ path to be created
+           -> m ()
+createLink link exe = do
+#if defined(IS_WINDOWS)
+  AppState { dirs } <- ask
+  let shimGen = cacheDir dirs </> "gs.exe"
+
+  let shim = dropExtension exe <.> "shim"
+      -- For hardlinks, link needs to be absolute.
+      -- If link is relative, it's relative to the target exe.
+      -- Note that (</>) drops lhs when rhs is absolute.
+      fullLink = takeDirectory exe </> link
+      shimContents = "path = " <> fullLink
+
+  $(logDebug) [i|rm -f #{exe}|]
+  liftIO $ rmLink exe
+
+  $(logDebug) [i|ln -s #{fullLink} #{exe}|]
+  liftIO $ copyFile shimGen exe
+  liftIO $ writeFile shim shimContents
+#else
+  $(logDebug) [i|rm -f #{exe}|]
+  liftIO $ hideError doesNotExistErrorType $ rmFile exe
+
+  $(logDebug) [i|ln -s #{link} #{exe}|]
+  liftIO $ createFileLink link exe
+#endif
+
+
+ensureGlobalTools :: ( MonadMask m
+                     , MonadThrow m
+                     , MonadLogger m
+                     , MonadIO m
+                     , MonadReader AppState m
+                     , MonadUnliftIO m
+                     , MonadFail m
+                     )
+                  => Excepts '[DigestError , DownloadFailed, NoDownload] m ()
+ensureGlobalTools = do
+#if defined(IS_WINDOWS)
+  AppState { ghcupInfo = GHCupInfo _ _ gTools, settings, dirs } <- lift ask
+  shimDownload <- liftE $ lE @_ @'[NoDownload]
+    $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
+  let dl = downloadCached' settings dirs shimDownload (Just "gs.exe")
+  void $ (\(DigestError _ _) -> do
+      lift $ $(logWarn) [i|Digest doesn't match, redownloading gs.exe...|]
+      lift $ $(logDebug) [i|rm -f #{shimDownload}|]
+      liftIO $ hideError doesNotExistErrorType $ rmFile (cacheDir dirs </> "gs.exe")
+      liftE @'[DigestError , DownloadFailed] $ dl
+    ) `catchE` (liftE @'[DigestError , DownloadFailed] dl)
+  pure ()
+#else
+  pure ()
+#endif
--- a/lib/GHCup/Utils.hs-boot
+++ b/lib/GHCup/Utils.hs-boot
@@ -0,0 +1,4 @@
+module GHCup.Utils where
+
+getLinkTarget :: FilePath -> IO FilePath
+pathIsLink :: FilePath -> IO Bool
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -17,6 +17,7 @@ Portability : portable
 -}
 module GHCup.Utils.Dirs
  ( getDirs
+  , ghcupBaseDir
  , ghcupConfigFile
  , ghcupCacheDir
  , ghcupGHCBaseDir
@@ -46,10 +47,14 @@ import           Data.Maybe
 import           Data.String.Interpolate
 import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
 import           Haskus.Utils.Variant.Excepts
+#if !defined(IS_WINDOWS)
 import           Optics
-import           System.Directory
+import           System.Directory                                                
+#endif
 import           System.DiskSpace                                                
+#if !defined(IS_WINDOWS)
 import           System.Environment
+#endif
 import           System.FilePath
 import           System.IO.Temp

@@ -72,6 +77,9 @@ import Control.Concurrent (threadDelay)
 -- then uses 'XDG_DATA_HOME/ghcup' as per xdg spec.
 ghcupBaseDir :: IO FilePath
 ghcupBaseDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup")
+#else
  xdg <- useXDG
  if xdg
    then do
@@ -86,6 +94,7 @@ ghcupBaseDir = do
        Just r  -> pure r
        Nothing -> liftIO getHomeDirectory
      pure (bdir </> ".ghcup")
+#endif


 -- | ~/.ghcup by default
@@ -94,6 +103,9 @@ ghcupBaseDir = do
 -- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
 ghcupConfigDir :: IO FilePath
 ghcupConfigDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup")
+#else
  xdg <- useXDG
  if xdg
    then do
@@ -108,6 +120,7 @@ ghcupConfigDir = do
        Just r  -> pure r
        Nothing -> liftIO getHomeDirectory
      pure (bdir </> ".ghcup")
+#endif


 -- | If 'GHCUP_USE_XDG_DIRS' is set (to anything),
@@ -115,6 +128,9 @@ ghcupConfigDir = do
 -- (which, sadly is not strictly xdg spec).
 ghcupBinDir :: IO FilePath
 ghcupBinDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "bin")
+#else
  xdg <- useXDG
  if xdg
    then do
@@ -124,6 +140,7 @@ ghcupBinDir = do
          home <- liftIO getHomeDirectory
          pure (home </> ".local" </> "bin")
    else ghcupBaseDir <&> (</> "bin")
+#endif


 -- | Defaults to '~/.ghcup/cache'.
@@ -132,6 +149,9 @@ ghcupBinDir = do
 -- then uses 'XDG_CACHE_HOME/ghcup' as per xdg spec.
 ghcupCacheDir :: IO FilePath
 ghcupCacheDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "cache")
+#else
  xdg <- useXDG
  if xdg
    then do
@@ -142,6 +162,7 @@ ghcupCacheDir = do
          pure (home </> ".cache")
      pure (bdir </> "ghcup")
    else ghcupBaseDir <&> (</> "cache")
+#endif


 -- | Defaults to '~/.ghcup/logs'.
@@ -150,6 +171,9 @@ ghcupCacheDir = do
 -- then uses 'XDG_CACHE_HOME/ghcup/logs' as per xdg spec.
 ghcupLogsDir :: IO FilePath
 ghcupLogsDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "logs")
+#else
  xdg <- useXDG
  if xdg
    then do
@@ -160,6 +184,7 @@ ghcupLogsDir = do
          pure (home </> ".cache")
      pure (bdir </> "ghcup" </> "logs")
    else ghcupBaseDir <&> (</> "logs")
+#endif


 getDirs :: IO Dirs
@@ -242,7 +267,7 @@ mkGhcupTmpDir = do


 withGHCupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadResource m, MonadThrow m, MonadIO m) => m FilePath
-withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir) removeDirectoryRecursive)
+withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir) rmPath)



@@ -252,8 +277,10 @@ withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir
    --------------


+#if !defined(IS_WINDOWS)
 useXDG :: IO Bool
 useXDG = isJust <$> lookupEnv "GHCUP_USE_XDG_DIRS"
+#endif


 relativeSymlink :: FilePath  -- ^ the path in which to create the symlink
--- a/lib/GHCup/Utils/File/Common.hs
+++ b/lib/GHCup/Utils/File/Common.hs
@@ -8,7 +8,6 @@ module GHCup.Utils.File.Common where

 import           GHCup.Utils.Prelude

-import           Control.Exception
 import           Control.Monad.Extra
 import           Control.Monad.Reader
 import           Data.Maybe
@@ -17,7 +16,6 @@ import           GHC.IO.Exception
 import           Optics                  hiding ((<|), (|>))
 import           System.Directory
 import           System.FilePath
-import           System.IO.Error
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix

@@ -106,17 +104,3 @@ findFiles path regex = do
  contents <- listDirectory path
  pure $ filter (match regex) contents

-
-isBrokenSymlink :: FilePath -> IO Bool
-isBrokenSymlink fp = do
-  try (pathIsSymbolicLink fp) >>= \case
-    Right True -> do
-      let symDir = takeDirectory fp
-      tfp <- getSymbolicLinkTarget fp
-      not <$> doesPathExist
-        -- this drops 'symDir' if 'tfp' is absolute
-        (symDir </> tfp)
-    Right b -> pure b
-    Left e | isDoesNotExistError e -> pure False
-           | otherwise -> throwIO e
-
--- a/lib/GHCup/Utils/File/Posix.hs
+++ b/lib/GHCup/Utils/File/Posix.hs
@@ -42,6 +42,7 @@ import           System.Console.Pretty   hiding ( Pretty )
 import           System.Console.Regions
 import           System.IO.Error
 import           System.FilePath
+import           System.Directory
 import           System.Posix.Directory
 import           System.Posix.Files
 import           System.Posix.IO
@@ -63,11 +64,12 @@ import qualified "unix-bytestring" System.Posix.IO.ByteString

 -- | Execute the given command and collect the stdout, stderr and the exit code.
 -- The command is run in a subprocess.
-executeOut :: FilePath          -- ^ command as filename, e.g. 'ls'
+executeOut :: MonadIO m
+           => FilePath          -- ^ command as filename, e.g. 'ls'
           -> [String]          -- ^ arguments to the command
           -> Maybe FilePath    -- ^ chdir to this path
-           -> IO CapturedProcess
-executeOut path args chdir = captureOutStreams $ do
+           -> m CapturedProcess
+executeOut path args chdir = liftIO $ captureOutStreams $ do
  maybe (pure ()) changeWorkingDirectory chdir
  SPP.executeFile path True args Nothing

@@ -316,12 +318,13 @@ createRegularFileFd fm dest =


 -- | Thin wrapper around `executeFile`.
-exec :: String           -- ^ thing to execute
+exec :: MonadIO m
+     => String           -- ^ thing to execute
     -> [String]         -- ^ args for the thing
     -> Maybe FilePath   -- ^ optionally chdir into this
     -> Maybe [(String, String)] -- ^ optional environment
-     -> IO (Either ProcessError ())
-exec exe args chdir env = do
+     -> m (Either ProcessError ())
+exec exe args chdir env = liftIO $ do
  pid <- SPP.forkProcess $ do
    maybe (pure ()) changeWorkingDirectory chdir
    SPP.executeFile exe (not ("./" `isPrefixOf` exe)) args env
@@ -366,3 +369,18 @@ newFilePerms =
    `unionFileModes` groupReadMode
    `unionFileModes` otherWriteMode
    `unionFileModes` otherReadMode
+
+
+-- | Checks whether the binary is a broken link.
+isBrokenSymlink :: FilePath -> IO Bool
+isBrokenSymlink fp = do
+  try (pathIsSymbolicLink fp) >>= \case
+    Right True -> do
+      let symDir = takeDirectory fp
+      tfp <- getSymbolicLinkTarget fp
+      not <$> doesPathExist
+        -- this drops 'symDir' if 'tfp' is absolute
+        (symDir </> tfp)
+    Right b -> pure b
+    Left e | isDoesNotExistError e -> pure False
+           | otherwise -> throwIO e
--- a/lib/GHCup/Utils/File/Windows.hs
+++ b/lib/GHCup/Utils/File/Windows.hs
@@ -15,6 +15,8 @@ Some of these functions use sophisticated logging.
 -}
 module GHCup.Utils.File.Windows where

+import {-# SOURCE #-} GHCup.Utils ( getLinkTarget, pathIsLink )
+import           GHCup.Utils.Dirs
 import           GHCup.Utils.File.Common
 import           GHCup.Types

@@ -23,10 +25,12 @@ import           Control.DeepSeq
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.Reader
+import           Data.List
 import           Foreign.C.Error
 import           GHC.IO.Exception
 import           GHC.IO.Handle
 import           System.Directory
+import           System.Environment
 import           System.FilePath
 import           System.IO
 import           System.Process
@@ -34,6 +38,7 @@ import           System.Process
 import qualified Control.Exception             as EX
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Lazy          as BL
+import qualified Data.Map.Strict               as Map



@@ -63,7 +68,7 @@ readCreateProcessWithExitCodeBS cp input = do
                    std_out = CreatePipe,
                    std_err = CreatePipe
                  }
-    withCreateProcess_ "readCreateProcessWithExitCode" cp_opts $
+    withCreateProcess_ "readCreateProcessWithExitCodeBS" cp_opts $
      \mb_inh mb_outh mb_errh ph ->
        case (mb_inh, mb_outh, mb_errh) of
          (Just inh, Just outh, Just errh) -> do
@@ -130,12 +135,14 @@ withForkWait async' body = do

 -- | Execute the given command and collect the stdout, stderr and the exit code.
 -- The command is run in a subprocess.
-executeOut :: FilePath          -- ^ command as filename, e.g. 'ls'
+executeOut :: MonadIO m
+           => FilePath          -- ^ command as filename, e.g. 'ls'
           -> [String]          -- ^ arguments to the command
           -> Maybe FilePath    -- ^ chdir to this path
-           -> IO CapturedProcess
+           -> m CapturedProcess
 executeOut path args chdir = do
-  (exit, out, err) <- readCreateProcessWithExitCodeBS (proc path args){ cwd = chdir } ""
+  cp <- createProcessWithMingwPath ((proc path args){ cwd = chdir })
+  (exit, out, err) <- liftIO $ readCreateProcessWithExitCodeBS cp ""
  pure $ CapturedProcess exit out err


@@ -150,15 +157,16 @@ execLogged exe args chdir lfile env = do
  AppState { dirs = Dirs {..} } <- ask
  let stdoutLogfile = logsDir </> lfile <> ".stdout.log"
      stderrLogfile = logsDir </> lfile <> ".stderr.log"
+  cp <- createProcessWithMingwPath ((proc exe args)
+    { cwd = chdir
+    , env = env
+    , std_in = CreatePipe
+    , std_out = CreatePipe
+    , std_err = CreatePipe
+    })
  fmap (toProcessError exe args)
    $ liftIO
-    $ withCreateProcess
-        (proc exe args){ cwd = chdir
-                       , env = env
-                       , std_in = CreatePipe
-                       , std_out = CreatePipe
-                       , std_err = CreatePipe
-        }
+    $ withCreateProcess cp
    $ \_ mout merr ph ->
        case (mout, merr) of
          (Just cStdout, Just cStderr) -> do
@@ -184,15 +192,15 @@ execLogged exe args chdir lfile env = do
        

 -- | Thin wrapper around `executeFile`.
-exec :: FilePath       -- ^ thing to execute
+exec :: MonadIO m
+     => FilePath       -- ^ thing to execute
     -> [FilePath]     -- ^ args for the thing
     -> Maybe FilePath   -- ^ optionally chdir into this
     -> Maybe [(String, String)] -- ^ optional environment
-     -> IO (Either ProcessError ())
+     -> m (Either ProcessError ())
 exec exe args chdir env = do
-  exit_code <- withCreateProcess
-                 (proc exe args) { cwd = chdir, env = env } $ \_ _ _ p ->
-                 waitForProcess p
+  cp <- createProcessWithMingwPath ((proc exe args) { cwd = chdir, env = env })
+  exit_code <- liftIO $ withCreateProcess cp $ \_ _ _ p -> waitForProcess p
  pure $ toProcessError exe args exit_code


@@ -200,3 +208,33 @@ chmod_755 :: MonadIO m => FilePath -> m ()
 chmod_755 fp =
  let perm = setOwnerWritable True emptyPermissions
  in liftIO $ setPermissions fp perm
+
+
+createProcessWithMingwPath :: MonadIO m
+                          => CreateProcess
+                          -> m CreateProcess
+createProcessWithMingwPath cp = do
+  baseDir <- liftIO ghcupBaseDir
+  cEnv <- Map.fromList <$> maybe (liftIO getEnvironment) pure (env cp)
+  let mingWPaths = [baseDir </> "msys64" </> "usr" </> "bin"
+                   ,baseDir </> "msys64" </> "mingw64" </> "bin"]
+      paths = ["PATH", "Path"]
+      curPaths = (\x -> maybe [] splitSearchPath (Map.lookup x cEnv)) =<< paths
+      newPath = intercalate [searchPathSeparator] (mingWPaths ++ curPaths)
+      envWithoutPath = foldr (\x y -> Map.delete x y) cEnv paths
+      envWithNewPath = Map.insert "Path" newPath envWithoutPath
+  liftIO $ setEnv "Path" newPath
+  pure $ cp { env = Just $ Map.toList envWithNewPath }
+
+
+-- | Checks whether the binary is a broken link.
+isBrokenSymlink :: FilePath -> IO Bool
+isBrokenSymlink fp = do
+  b <- pathIsLink fp
+  if b
+  then do
+    tfp <- getLinkTarget fp
+    not <$> doesPathExist
+      -- this drops 'symDir' if 'tfp' is absolute
+      (takeDirectory fp </> tfp)
+  else pure False
--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@@ -14,13 +14,11 @@ Here we define our main logger.
 -}
 module GHCup.Utils.Logger where

-import           GHCup.Types
 import           GHCup.Utils.File
 import           GHCup.Utils.String.QQ

 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Reader
 import           Control.Monad.Logger
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
@@ -68,9 +66,8 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
    rawOutter outr


-initGHCupFileLogging :: (MonadIO m, MonadReader AppState m) => m FilePath
-initGHCupFileLogging = do
-  AppState {dirs = Dirs {..}} <- ask
+initGHCupFileLogging :: (MonadIO m) => FilePath -> m FilePath
+initGHCupFileLogging logsDir = do
  let logfile = logsDir </> "ghcup.log"
  liftIO $ do
    createDirectoryIfMissing True logsDir
@@ -80,7 +77,7 @@ initGHCupFileLogging = do
                     execBlank
                     ([s|^.*\.log$|] :: B.ByteString)
      )
-    forM_ logFiles $ hideError doesNotExistErrorType . removeFile . (logsDir </>)
+    forM_ logFiles $ hideError doesNotExistErrorType . rmFile . (logsDir </>)

    writeFile logfile ""
    pure logfile
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP                 #-}
 {-# LANGUAGE DataKinds           #-}
 {-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE FlexibleInstances   #-}
@@ -25,6 +26,8 @@ import           Control.Monad.IO.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
+import           Data.List                      ( nub )
+import           Data.Foldable
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
@@ -32,6 +35,15 @@ import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
 import           System.IO.Error
+import           System.IO.Unsafe
+import           System.Directory
+import           System.FilePath
+
+#if defined(IS_WINDOWS)
+import           Control.Retry
+import           GHC.IO.Exception
+#endif
+
 import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
@@ -276,3 +288,139 @@ escapeVerRex = B.pack . go . B.unpack . verToBS
  go (x : xs) | x == _period = [_backslash, _period] ++ go xs
              | otherwise    = x : go xs

+-- | More permissive version of 'createDirRecursive'. This doesn't
+-- error when the destination is a symlink to a directory.
+createDirRecursive' :: FilePath -> IO ()
+createDirRecursive' p =
+  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
+    . createDirectoryIfMissing True
+    $ p
+
+ where
+  isSymlinkDir e = do
+    ft <- pathIsSymbolicLink p
+    case ft of
+      True -> do
+        rp <- canonicalizePath p
+        rft <- doesDirectoryExist rp
+        case rft of
+          True -> pure ()
+          _ -> throwIO e
+      _ -> throwIO e
+
+
+-- | Recursively copy the contents of one directory to another path.
+--
+-- This is a rip-off of Cabal library.
+copyDirectoryRecursive :: FilePath -> FilePath -> IO ()
+copyDirectoryRecursive srcDir destDir = do
+  srcFiles <- getDirectoryContentsRecursive srcDir
+  copyFilesWith copyFile destDir [ (srcDir, f)
+                                   | f <- srcFiles ]
+  where
+    -- | Common implementation of 'copyFiles', 'installOrdinaryFiles',
+    -- 'installExecutableFiles' and 'installMaybeExecutableFiles'.
+    copyFilesWith :: (FilePath -> FilePath -> IO ())
+                  -> FilePath -> [(FilePath, FilePath)] -> IO ()
+    copyFilesWith doCopy targetDir srcFiles = do
+
+      -- Create parent directories for everything
+      let dirs = map (targetDir </>) . nub . map (takeDirectory . snd) $ srcFiles
+      traverse_ (createDirectoryIfMissing True) dirs
+
+      -- Copy all the files
+      sequence_ [ let src  = srcBase   </> srcFile
+                      dest = targetDir </> srcFile
+                   in doCopy src dest
+                | (srcBase, srcFile) <- srcFiles ]
+
+    -- | List all the files in a directory and all subdirectories.
+    --
+    -- The order places files in sub-directories after all the files in their
+    -- parent directories. The list is generated lazily so is not well defined if
+    -- the source directory structure changes before the list is used.
+    --
+    getDirectoryContentsRecursive :: FilePath -> IO [FilePath]
+    getDirectoryContentsRecursive topdir = recurseDirectories [""]
+      where
+        recurseDirectories :: [FilePath] -> IO [FilePath]
+        recurseDirectories []         = return []
+        recurseDirectories (dir:dirs) = unsafeInterleaveIO $ do
+          (files, dirs') <- collect [] [] =<< getDirectoryContents (topdir </> dir)
+          files' <- recurseDirectories (dirs' ++ dirs)
+          return (files ++ files')
+
+          where
+            collect files dirs' []              = return (reverse files
+                                                         ,reverse dirs')
+            collect files dirs' (entry:entries) | ignore entry
+                                                = collect files dirs' entries
+            collect files dirs' (entry:entries) = do
+              let dirEntry = dir </> entry
+              isDirectory <- doesDirectoryExist (topdir </> dirEntry)
+              if isDirectory
+                then collect files (dirEntry:dirs') entries
+                else collect (dirEntry:files) dirs' entries
+
+            ignore ['.']      = True
+            ignore ['.', '.'] = True
+            ignore _          = False
+
+-- https://github.com/haskell/directory/issues/110
+-- https://github.com/haskell/directory/issues/96
+-- https://www.sqlite.org/src/info/89f1848d7f
+rmPath :: (MonadIO m, MonadMask m)
+      => FilePath
+      -> m ()
+rmPath fp =
+#if defined(IS_WINDOWS)
+  recovering (fullJitterBackoff 25000 <> limitRetries 10)
+    [\_ -> Handler (\e -> pure $ isPermissionError e)
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == InappropriateType))
+    ]
+    (\_ -> liftIO $ removePathForcibly fp)
+#else
+  liftIO $ removeDirectoryRecursive fp
+#endif
+
+
+-- https://www.sqlite.org/src/info/89f1848d7f
+-- https://github.com/haskell/directory/issues/96
+rmFile :: (MonadIO m, MonadMask m)
+      => FilePath
+      -> m ()
+rmFile fp =
+#if defined(IS_WINDOWS)
+  recovering (fullJitterBackoff 25000 <> limitRetries 10)
+    [\_ -> Handler (\e -> pure $ isPermissionError e)
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
+    ]
+    (\_ -> liftIO $ removeFile fp)
+#else
+  liftIO $ removeFile fp
+#endif
+
+
+-- Gathering monoidal values
+traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
+traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
+
+-- | Gathering monoidal values
+forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
+forFold = \t -> (`traverseFold` t)
+
+
+-- | Strip @\\r@ and @\\n@ from 'ByteString's
+stripNewline :: String -> String
+stripNewline s
+  | null s               = []
+  | head s `elem` "\n\r" = stripNewline (tail s)
+  | otherwise            = head s : stripNewline (tail s)
+
+
+isNewLine :: Word8 -> Bool
+isNewLine w
+  | w == _lf = True
+  | w == _cr = True
+  | otherwise = False
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -25,7 +25,7 @@ import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.5.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@@ -171,6 +171,10 @@ instance Arbitrary Tool where
  arbitrary = genericArbitrary
  shrink    = genericShrink

+instance Arbitrary GlobalTool where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
 instance Arbitrary GHCupInfo where
  arbitrary = genericArbitrary
  shrink    = genericShrink
--- a/www/index.html
+++ b/www/index.html
@@ -20,7 +20,7 @@
      </a>

      <p id="pitch">
-        <em>ghcup</em> is an installer for<br/>
+        <em>ghcup</em> is the main installer for<br/>
        the general purpose language <a href="https://www.haskell.org/">Haskell</a>
      </p>

@@ -124,7 +124,7 @@
      </div>

      <p>
-        Need help? <a href="http://webchat.freenode.net/?randomnick=1&channels=%23haskell&uio=d4">Ask on #haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
+        Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell-ghcup">#haskell-ghcup</a>, <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell">#haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
      </p>

      <p id="about">
@@ -145,7 +145,7 @@

    <noscript>
      <p id="pitch">
-        <em>ghcup</em> is an installer for<br/>
+        <em>ghcup</em> is the main installer for<br/>
        the general purpose language <a href="https://www.haskell.org/">Haskell</a>
      </p>

@@ -171,7 +171,7 @@
      </div>

      <p>
-        Need help? <a href="http://webchat.freenode.net/?randomnick=1&amp;channels=%23haskell&amp;uio=d4">Ask on #haskell</a>.
+        Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell-ghcup">#haskell-ghcup</a>, <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell">#haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
      </p>

      <p id="about">
Author	SHA1	Message	Date
Julian Ospald	2f62067d96	Windows support	2021-06-05 21:01:01 +02:00
Julian Ospald	9793fc6888	Update stack things	2021-05-30 15:17:04 +02:00
Julian Ospald	043cab08ae	Update www	2021-05-20 19:21:57 +02:00
Julian Ospald	b7c83780da	Update remaining links	2021-05-19 19:22:51 +02:00
Julian Ospald	cff11135ff	Update IRC link	2021-05-19 19:19:12 +02:00