Fix FreeBSD 13 build

2021-12-02 16:24:25 +01:00
27 changed files with 274 additions and 666 deletions
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -8,15 +8,7 @@ set -eux

 mkdir -p "${TMPDIR}"

-if freebsd-version | grep -E '^12.*' ; then
-	freebsd_ver=12
-elif freebsd-version | grep -E '^13.*' ; then
-	freebsd_ver=13
-else
-	(>&2 echo "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues")
-	exit 1
-fi
-curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-freebsd${freebsd_ver}-ghcup > ./ghcup-bin
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

 ./ghcup-bin -v upgrade -i -f
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -495,7 +495,7 @@ set' _ (_, ListResult {..}) = do
      case lTool of
        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly $> ()
        Cabal -> liftE $ setCabal lVer $> ()
-        HLS   -> liftE $ setHLS lVer SetHLSOnly $> ()
+        HLS   -> liftE $ setHLS lVer $> ()
        Stack -> liftE $ setStack lVer $> ()
        GHCup -> pure ()
    )
--- a/app/ghcup/GHCup/OptParse.hs
+++ b/app/ghcup/GHCup/OptParse.hs
@@ -15,9 +15,7 @@ module GHCup.OptParse (
  , module GHCup.OptParse.Config
  , module GHCup.OptParse.Whereis
  , module GHCup.OptParse.List
-#ifndef DISABLE_UPGRADE
  , module GHCup.OptParse.Upgrade
-#endif
  , module GHCup.OptParse.ChangeLog
  , module GHCup.OptParse.Prefetch
  , module GHCup.OptParse.GC
@@ -37,9 +35,7 @@ import           GHCup.OptParse.Compile
 import           GHCup.OptParse.Config
 import           GHCup.OptParse.Whereis
 import           GHCup.OptParse.List
-#ifndef DISABLE_UPGRADE
 import           GHCup.OptParse.Upgrade
-#endif
 import           GHCup.OptParse.ChangeLog
 import           GHCup.OptParse.Prefetch
 import           GHCup.OptParse.GC
@@ -93,9 +89,7 @@ data Command
  | Compile CompileCommand
  | Config ConfigCommand
  | Whereis WhereisOptions WhereisCommand
-#ifndef DISABLE_UPGRADE
  | Upgrade UpgradeOpts Bool
-#endif
  | ToolRequirements
  | ChangeLog ChangeLogOptions
  | Nuke
@@ -214,7 +208,6 @@ com =
           (info (List <$> listOpts <**> helper)
                 (progDesc "Show available GHCs and other tools")
           )
-#ifndef DISABLE_UPGRADE
      <> command
           "upgrade"
           (info
@@ -225,7 +218,6 @@ com =
             )
             (progDesc "Upgrade ghcup")
           )
-#endif
      <> command
           "compile"
           (   Compile
--- a/app/ghcup/GHCup/OptParse/Common.hs
+++ b/app/ghcup/GHCup/OptParse/Common.hs
@@ -89,6 +89,18 @@ toolVersionArgument criteria tool =
  mv _          = "VERSION|TAG"


+toolVersionOption :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
+toolVersionOption criteria tool =
+  option (eitherReader toolVersionEither)
+    (  sh tool
+    <> completer (tagCompleter (fromMaybe GHC tool) [])
+    <> foldMap (completer . versionCompleter criteria) tool)
+ where
+  sh (Just GHC) = long "ghc" <> metavar "GHC_VERSION|TAG"
+  sh (Just HLS) = long "hls" <> metavar "HLS_VERSION|TAG"
+  sh _          = long "version" <> metavar "VERSION|TAG"
+
+
 versionParser :: Parser GHCTargetVersion
 versionParser = option
  (eitherReader tVersionEither)
--- a/app/ghcup/GHCup/OptParse/Compile.hs
+++ b/app/ghcup/GHCup/OptParse/Compile.hs
@@ -212,7 +212,7 @@ ghcCompileOpts =
            (fmap Left $ option
              str
              (short 'p' <> long "patchdir" <> metavar "PATCH_DIR" <> help
-                "Absolute path to patch directory (applies all .patch and .diff files in order using -p1. This order is determined by a quilt series file if it exists, or the patches are lexicographically ordered)"
+                "Absolute path to patch directory (applies all .patch and .diff files in order using -p1)"
              )
            )
          )
@@ -340,12 +340,7 @@ hlsCompileOpts =
            )
          )
        )
-    <*> some (
-          option (eitherReader toolVersionEither)
-            (  long "ghc" <> metavar "GHC_VERSION|TAG" <> help "For which GHC version to compile for (can be specified multiple times)"
-            <> completer (tagCompleter GHC [])
-            <> completer (versionCompleter Nothing GHC))
-        )
+    <*> some (toolVersionOption Nothing (Just GHC))
    <*> many (argument str (metavar "CABAL_ARGS" <> help "Additional arguments to cabal install, prefix with '-- ' (longopts)"))


@@ -466,7 +461,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
        let vi = getVersionInfo targetVer HLS dls
        when setCompile $ void $ liftE $
-          setHLS targetVer SetHLSOnly
+          setHLS targetVer
        pure (vi, targetVer)
        )
        >>= \case
--- a/app/ghcup/GHCup/OptParse/GC.hs
+++ b/app/ghcup/GHCup/OptParse/GC.hs
@@ -132,7 +132,7 @@ gc GCOptions{..} runAppState runLogger = runGC runAppState (do
  when gcOldGHC rmOldGHC
  lift $ when gcProfilingLibs rmProfilingLibs
  lift $ when gcShareDir rmShareDir
-  liftE $ when gcHLSNoGHC rmHLSNoGHC
+  lift $ when gcHLSNoGHC rmHLSNoGHC
  lift $ when gcCache rmCache
  lift $ when gcTmp rmTmp
   ) >>= \case
--- a/app/ghcup/GHCup/OptParse/Install.hs
+++ b/app/ghcup/GHCup/OptParse/Install.hs
@@ -268,64 +268,6 @@ runInstTool appstate' mInstPlatform =
    @InstallEffects


-type InstallGHCEffects = '[ TagNotFound
-                          , NextVerNotFound
-                          , NoToolVersionSet
-                          , BuildFailed
-                          , DirNotEmpty
-                          , AlreadyInstalled
-
-                          , (AlreadyInstalled, NotInstalled)
-                          , (UnknownArchive, NotInstalled)
-                          , (ArchiveResult, NotInstalled)
-                          , (FileDoesNotExistError, NotInstalled)
-                          , (CopyError, NotInstalled)
-                          , (NotInstalled, NotInstalled)
-                          , (DirNotEmpty, NotInstalled)
-                          , (NoDownload, NotInstalled)
-                          , (BuildFailed, NotInstalled)
-                          , (TagNotFound, NotInstalled)
-                          , (DigestError, NotInstalled)
-                          , (GPGError, NotInstalled)
-                          , (DownloadFailed, NotInstalled)
-                          , (TarDirDoesNotExist, NotInstalled)
-                          , (NextVerNotFound, NotInstalled)
-                          , (NoToolVersionSet, NotInstalled)
-                          , (FileAlreadyExistsError, NotInstalled)
-                          , (ProcessError, NotInstalled)
-
-                          , (AlreadyInstalled, ())
-                          , (UnknownArchive, ())
-                          , (ArchiveResult, ())
-                          , (FileDoesNotExistError, ())
-                          , (CopyError, ())
-                          , (NotInstalled, ())
-                          , (DirNotEmpty, ())
-                          , (NoDownload, ())
-                          , (BuildFailed, ())
-                          , (TagNotFound, ())
-                          , (DigestError, ())
-                          , (GPGError, ())
-                          , (DownloadFailed, ())
-                          , (TarDirDoesNotExist, ())
-                          , (NextVerNotFound, ())
-                          , (NoToolVersionSet, ())
-                          , (FileAlreadyExistsError, ())
-                          , (ProcessError, ())
-
-                          , ((), NotInstalled)
-                          ]
-
-runInstGHC :: AppState
-           -> Maybe PlatformRequest
-           -> Excepts InstallGHCEffects (ResourceT (ReaderT AppState IO)) a
-           -> IO (VEither InstallGHCEffects a)
-runInstGHC appstate' mInstPlatform =
-  flip runReaderT (maybe appstate' (\x -> appstate'{ pfreq = x } :: AppState) mInstPlatform)
-  . runResourceT
-  . runE
-    @InstallGHCEffects
-

    -------------------
    --[ Entrypoints ]--
@@ -346,25 +288,23 @@ install installCommand settings getAppState' runLogger = case installCommand of
  installGHC InstallOptions{..} = do
    s'@AppState{ dirs = Dirs{ .. } } <- liftIO getAppState'
    (case instBindist of
-       Nothing -> runInstGHC s' instPlatform $ do
+       Nothing -> runInstTool s' instPlatform $ do
         (v, vi) <- liftE $ fromVersion instVer GHC
-         void $ liftE $ sequenceE (installGHCBin
+         liftE $ installGHCBin
+                   (_tvVersion v)
+                   isolateDir
+                   forceInstall
+         when instSet $ void $ liftE $ setGHC v SetGHCOnly
+         pure vi
+       Just uri -> do
+         runInstTool s'{ settings = settings {noVerify = True}} instPlatform $ do
+           (v, vi) <- liftE $ fromVersion instVer GHC
+           liftE $ installGHCBindist
+                     (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                     (_tvVersion v)
                     isolateDir
                     forceInstall
-                   )
-                   $ when instSet $ void $ setGHC v SetGHCOnly
-         pure vi
-       Just uri -> do
-         runInstGHC s'{ settings = settings {noVerify = True}} instPlatform $ do
-           (v, vi) <- liftE $ fromVersion instVer GHC
-           void $ liftE $ sequenceE (installGHCBindist
-                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
-                       (_tvVersion v)
-                       isolateDir
-                       forceInstall
-                     )
-                     $ when instSet $ void $ setGHC v SetGHCOnly
+           when instSet $ void $ liftE $ setGHC v SetGHCOnly
           pure vi
      )
        >>= \case
@@ -373,25 +313,14 @@ install installCommand settings getAppState' runLogger = case installCommand of
                forM_ (_viPostInstall =<< vi) $ \msg ->
                  runLogger $ logInfo msg
                pure ExitSuccess
-
-              VLeft (V (AlreadyInstalled _ v, ())) -> do
-                runLogger $ logWarn $
-                  "GHC ver " <> prettyVer v <> " already installed; if you really want to reinstall it, you may want to run 'ghcup install ghc --force " <> prettyVer v <> "'"
-                pure ExitSuccess
              VLeft (V (AlreadyInstalled _ v)) -> do
                runLogger $ logWarn $
                  "GHC ver " <> prettyVer v <> " already installed; if you really want to reinstall it, you may want to run 'ghcup install ghc --force " <> prettyVer v <> "'"
                pure ExitSuccess
-
              VLeft (V (DirNotEmpty fp)) -> do
                runLogger $ logWarn $
                  "Install directory " <> T.pack fp <> " is not empty. Use 'ghcup install ghc --isolate " <> T.pack fp <> " --force ..." <> "' to install regardless."
                pure $ ExitFailure 3
-              VLeft (V (DirNotEmpty fp, ())) -> do
-                runLogger $ logWarn $
-                  "Install directory " <> T.pack fp <> " is not empty. Use 'ghcup install ghc --isolate " <> T.pack fp <> " --force ..." <> "' to install regardless."
-                pure $ ExitFailure 3
-
              VLeft err@(V (BuildFailed tmpdir _)) -> do
                case keepDirs settings of
                  Never -> runLogger (logError $ T.pack $ prettyShow err)
@@ -399,14 +328,6 @@ install installCommand settings getAppState' runLogger = case installCommand of
                    "Check the logs at " <> T.pack logsDir <> " and the build directory " <> T.pack tmpdir <> " for more clues." <> "\n" <>
                    "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
                pure $ ExitFailure 3
-              VLeft err@(V (BuildFailed tmpdir _, ())) -> do
-                case keepDirs settings of
-                  Never -> runLogger (logError $ T.pack $ prettyShow err)
-                  _ -> runLogger (logError $ T.pack (prettyShow err) <> "\n" <>
-                    "Check the logs at " <> T.pack logsDir <> " and the build directory " <> T.pack tmpdir <> " for more clues." <> "\n" <>
-                    "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
-                pure $ ExitFailure 3
-
              VLeft e -> do
                runLogger $ do
                  logError $ T.pack $ prettyShow e
@@ -469,9 +390,8 @@ install installCommand settings getAppState' runLogger = case installCommand of
       Just uri -> do
         runInstTool s'{ settings = settings { noVerify = True}} instPlatform $ do
           (v, vi) <- liftE $ fromVersion instVer HLS
-           -- TODO: support legacy
           liftE $ installHLSBindist
-                     (DownloadInfo uri (Just $ RegexDir "haskell-language-server-*") "")
+                     (DownloadInfo uri Nothing "")
                     (_tvVersion v)
                     isolateDir
                     forceInstall
--- a/app/ghcup/GHCup/OptParse/Set.hs
+++ b/app/ghcup/GHCup/OptParse/Set.hs
@@ -311,10 +311,10 @@ set setCommand runAppState runLeanAppState runLogger = case setCommand of
          -> m ExitCode
  setHLS' SetOptions{ sToolVer } =
    case sToolVer of
-      (SetToolVersion v) -> runSetHLS runLeanAppState (liftE $ setHLS (_tvVersion v) SetHLSOnly >> pure v)
+      (SetToolVersion v) -> runSetHLS runLeanAppState (liftE $ setHLS (_tvVersion v) >> pure v)
      _ -> runSetHLS runAppState (do
          v <- liftE $ fst <$> fromVersion' sToolVer HLS
-          liftE $ setHLS (_tvVersion v) SetHLSOnly
+          liftE $ setHLS (_tvVersion v)
          pure v
        )
      >>= \case
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -140,12 +140,7 @@ main = do
        <> hidden
        )
  let listCommands = infoOption
-        ("install set rm install-cabal list"
-#ifndef DISABLE_UPGRADE
-          <> " upgrade"
-#endif
-          <> " compile debug-info tool-requirements changelog"
-        )
+        "install set rm install-cabal list upgrade compile debug-info tool-requirements changelog"
        (  long "list-commands"
        <> help "List available commands for shell completion"
        <> internal
@@ -243,14 +238,10 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                             alreadyInstalling' <- alreadyInstalling optCommand newTool
                             when (not alreadyInstalling') $
                               case t of
-#ifdef DISABLE_UPGRADE
-                                 GHCup -> pure ()
-#else
                                 GHCup -> runLogger $
                                            logWarn ("New GHCup version available: "
                                              <> prettyVer l
                                              <> ". To upgrade, run 'ghcup upgrade'")
-#endif
                                 _ -> runLogger $
                                        logWarn ("New "
                                          <> T.pack (prettyShow t)
@@ -305,9 +296,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
            Config configCommand     -> config configCommand settings keybindings runLogger
            Whereis whereisOptions
                    whereisCommand   -> whereis whereisCommand whereisOptions runAppState leanAppstate runLogger
-#ifndef DISABLE_UPGRADE
            Upgrade uOpts force'     -> upgrade uOpts force' dirs runAppState runLogger
-#endif
            ToolRequirements         -> toolRequirements runAppState runLogger
            ChangeLog changelogOpts  -> changelog changelogOpts runAppState runLogger
            Nuke                     -> nuke appState runLogger
@@ -350,9 +339,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
    (HLS, ver)   = cmp' HLS (Just $ ToolVersion (mkTVer over)) ver
  alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ targetHLS = Left tver }))
    (HLS, ver)   = cmp' HLS (Just $ ToolVersion (mkTVer tver)) ver
-#ifndef DISABLE_UPGRADE
  alreadyInstalling (Upgrade _ _) (GHCup, _) = pure True
-#endif
  alreadyInstalling _ _ = pure False

  cmp' :: ( HasLog env
--- a/cabal.project
+++ b/cabal.project
@@ -15,7 +15,8 @@ source-repository-package

 constraints: http-io-streams -brotli,
             any.Cabal ==3.6.2.0,
-             any.aeson >= 2.0.1.0
+             any.aeson >= 2.0.1.0,
+             streamly == 0.8.0

 package libarchive
  flags: -system-libarchive
--- a/docs/dev.md
+++ b/docs/dev.md
@@ -12,7 +12,8 @@ organised tree-ish in `GHCup.Utils` and `GHCup.Utils.*`.
 Anything dealing with ghcup specific directories is in
 `GHCup.Utils.Dirs`.

-Download information on where to fetch bindists from is in the [ghcup-metadata](https://github.com/haskell/ghcup-metadata) repository.
+Download information on where to fetch bindists from is in the appropriate
+yaml files: `data/metadata/ghcup-<yaml-ver>.yaml`.

 ## Design decisions

--- a/docs/guide.md
+++ b/docs/guide.md
@@ -32,17 +32,6 @@ ghcup install cabal
 ghcup upgrade
 ```

-### Tags and shortcuts
-
-GHCup has a number of tags and version shortcuts, that can be used as arguments to **install**/**set** etc.
-All of the following are valid arguments to `ghcup install ghc`:
-
-* `latest`, `recommended`
-* `base-4.15.1.0`
-* `9.0.2`, `9.0`, `9`
-
-If the argument is omitted, the default is `recommended`.
-
 ## Configuration

 A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
@@ -149,31 +138,6 @@ and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
 GHCup always needs to know which version the bindist corresponds to (this is not automatically
 detected).

-## Mirrors
-
-GHCup allows to use custom mirrors/download-info hosted by yourself or 3rd parties.
-
-To use a mirror, set the following option in `~/.ghcup/config.yaml`:
-
-```yml
-url-source:
-  # Accepts file/http/https scheme
-  OwnSource: "https://some-url/ghcup-0.0.6.yaml"
-```
-
-See [config.yaml](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/data/config.yaml)
-for more options.
-
-Alternatively you can do it via a cli switch:
-
-```sh
-ghcup --url-source=https://some-url/ghcup-0.0.6.yaml list
-```
-
-### Known mirrors
-
-1. [https://mirror.sjtu.edu.cn/docs/ghcup](https://mirror.sjtu.edu.cn/docs/ghcup)
-
 ## Isolated installs

 Ghcup also enables you to install a tool (GHC, Cabal, HLS, Stack) at an isolated location of your choosing.
@@ -224,10 +188,66 @@ For the full list of env variables and parameters to tweak the script behavior,
 * [bootstrap-haskell for linux/darwin/freebsd](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell#L7)
 * [bootstrap-haskell.ps1 for windows](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1#L17)

-### github workflows
+### Example github workflow

-On github workflows you can use [https://github.com/haskell/actions/](https://github.com/haskell/actions/).
-GHCup itself is also pre-installed on all platforms, but may use non-standard install locations.
+On github workflows you can use [https://github.com/haskell/actions/](https://github.com/haskell/actions/)
+
+If you want to install ghcup manually though, here's an example config:
+
+```yml
+name: Haskell CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build-cabal:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+        ghc: ['8.10.7', '9.0.1']
+        cabal: ['3.4.0.0']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - if: matrix.os == 'windows-latest'
+      name: Install ghcup on windows
+      run: Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false,$true,$true,$false,$false,$false,$false,"C:\"
+
+    - if: matrix.os == 'windows-latest'
+      name: Add ghcup to PATH
+      run: echo "/c/ghcup/bin" >> $GITHUB_PATH
+      shell: bash
+
+    - if: matrix.os != 'windows-latest'
+      name: Install ghcup on non-windows
+      run: curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
+
+    - name: Install ghc/cabal
+      run: |
+        ghcup install ghc ${{ matrix.ghc }}
+        ghcup install cabal ${{ matrix.cabal }}
+      shell: bash
+
+    - name: Update cabal index
+      run: cabal update
+      shell: bash
+
+    - name: Build
+      run: cabal build --enable-tests --enable-benchmarks
+      shell: bash
+
+    - name: Run tests
+      run: cabal test
+      shell: bash
+```

 ## GPG verification

--- a/docs/install.md
+++ b/docs/install.md
@@ -24,20 +24,10 @@ Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager

 If you want to know what these scripts do, check out the [source code at the repository](https://gitlab.haskell.org/haskell/ghcup-hs/-/tree/master/scripts/bootstrap). Advanced users may want to perform a [manual installation](#manual-install) and GPG verify the binaries.

-### Which versions get installed?
-
-GHCup has two main channels for every tool: **recommended** and **latest**. By default, it installs *recommended*.
-
-*latest* follows the latest release of every tool, while *recommended* is at the discretion of the GHCup maintainers and based on community adoption (hackage libraries, tools like HLS, stackage support, etc.) and known bugs.
-
-Also see [tags and shortcuts](../guide/#tags-and-shortcuts) for more information.
-
 ## First steps

 1. To get started with creating a Haskell project, follow the [Getting Started with Haskell and Cabal](https://cabal.readthedocs.io/en/latest/getting-started.html) guide
-2. To learn Haskell, try any of those:
-    - A beginner friendly [4-lectures course](https://github.com/haskell-beginners-2022/course-plan) with exercises (by [Kowainik](https://kowainik.github.io/))
-    - An in-depth university [CIS 194 Haskell course](https://www.cis.upenn.edu/~cis194/spring13/) including exercises (by [Brent Yorgey](https://byorgey.wordpress.com/))
+2. To properly learn Haskell, run through the [CIS 194 Haskell course](https://www.cis.upenn.edu/~cis194/spring13/) including exercises
 3. To learn more about Haskell Toolchain management, check out the [ghcup user guide](./guide.md)

 ## Uninstallation
@@ -88,15 +78,14 @@ May or may not work, several issues:

 Unsupported. GHC may or may not work. Upgrade to WSL2.

-### MacOS <10.13
+### MacOS <13

-Not supported. Would require separate binaries, since >=10.13 binaries are incompatible.
+Not supported. Would require separate binaries, since >=13 binaries are incompatible.
 Please upgrade.

 ### MacOS aarch64

-HLS bindists are still experimental. Stack has only unofficial binaries for this platform.
-There are various issues with GHC itself.
+HLS bindists are still experimental. Stack is theoretically supported, but has no binaries yet.

 ### FreeBSD

@@ -105,7 +94,7 @@ HLS bindists are experimental.

 ### Linux ARMv7/AARCH64

-Lower availability of bindists. Stack and HLS binaries are experimental.
+Lower availability of bindists. HLS only has experimental ones. Stack not supported currently.

 ## Manual install

--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -48,13 +48,6 @@ flag no-exe
  default:     False
  manual:      True

-flag disable-upgrade
-  description:
-    Build the brick powered tui (ghcup tui). This is disabled on windows.
-
-  default:     False
-  manual:      True
-
 library
  exposed-modules:
    GHCup
@@ -202,6 +195,7 @@ executable ghcup
    GHCup.OptParse.Set
    GHCup.OptParse.ToolRequirements
    GHCup.OptParse.UnSet
+    GHCup.OptParse.Upgrade
    GHCup.OptParse.Whereis

  hs-source-dirs:     app/ghcup
@@ -268,12 +262,6 @@ executable ghcup
  if flag(no-exe)
    buildable: False

-  if (flag(disable-upgrade))
-    cpp-options:   -DDISABLE_UPGRADE
-  else
-    other-modules:
-        GHCup.OptParse.Upgrade
-
 test-suite ghcup-test
  type:               exitcode-stdio-1.0
  main-is:            Main.hs
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -5,8 +5,8 @@
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE QuasiQuotes           #-}

 {-|
 Module      : GHCup
@@ -301,6 +301,22 @@ installPackedGHC dl msubdir inst ver forceInstall = do
  liftE $ runBuildAction tmpUnpack
                         (Just inst)
                         (installUnpackedGHC workdir inst ver)
+ where
+  -- | Does basic checks for isolated installs
+  -- Isolated Directory:
+  --   1. if it doesn't exist -> proceed
+  --   2. if it exists and is empty -> proceed
+  --   3. if it exists and is non-empty -> panic and leave the house
+  installDestSanityCheck :: ( MonadIO m
+                            , MonadCatch m
+                            ) =>
+                            FilePath ->
+                            Excepts '[DirNotEmpty] m ()
+  installDestSanityCheck isoDir = do
+    hideErrorDef [doesNotExistErrorType] () $ do
+      contents <- liftIO $ getDirectoryContentsRecursive isoDir
+      unless (null contents) (throwE $ DirNotEmpty isoDir)
+


 -- | Install an unpacked GHC distribution. This only deals with the GHC
@@ -566,8 +582,6 @@ installHLSBindist :: ( MonadMask m
                        , TarDirDoesNotExist
                        , ArchiveResult
                        , FileAlreadyExistsError
-                        , ProcessError
-                        , DirNotEmpty
                        ]
                       m
                       ()
@@ -603,55 +617,26 @@ installHLSBindist dlinfo ver isoFilepath forceInstall = do

  -- the subdir of the archive where we do the work
  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
-  legacy <- liftIO $ isLegacyHLSBindist workdir
-
-  if
-    | not forceInstall
-    , not legacy
-    , (Just fp) <- isoFilepath -> liftE $ installDestSanityCheck fp
-    | otherwise -> pure ()

  case isoFilepath of
    Just isoDir -> do
      lift $ logInfo $ "isolated installing HLS to " <> T.pack isoDir
-      if legacy
-      then liftE $ installHLSUnpackedLegacy workdir isoDir Nothing forceInstall
-      else liftE $ installHLSUnpacked workdir isoDir ver
+      liftE $ installHLSUnpacked workdir isoDir Nothing forceInstall

    Nothing -> do
-      if legacy
-      then liftE $ installHLSUnpackedLegacy workdir binDir (Just ver) forceInstall
-      else do
-        inst <- ghcupHLSDir ver
-        liftE $ installHLSUnpacked workdir inst ver
-        liftE $ setHLS ver SetHLS_XYZ
+      liftE $ installHLSUnpacked workdir binDir (Just ver) forceInstall

  liftE $ installHLSPostInst isoFilepath ver

-isLegacyHLSBindist :: FilePath -- ^ Path to the unpacked hls bindist
-                   -> IO Bool
-isLegacyHLSBindist path = do
-  not <$> doesFileExist (path </> "GNUmakefile")

 -- | Install an unpacked hls distribution.
-installHLSUnpacked :: (MonadMask m, MonadUnliftIO m, MonadReader env m, MonadFail m, HasLog env, HasDirs env, HasSettings env, MonadCatch m, MonadIO m)
-                   => FilePath      -- ^ Path to the unpacked hls bindist (where the executable resides)
-                   -> FilePath      -- ^ Path to install to
-                   -> Version
-                   -> Excepts '[ProcessError, CopyError, FileAlreadyExistsError, NotInstalled] m ()
-installHLSUnpacked path inst _ = do
-  lift $ logInfo "Installing HLS"
-  liftIO $ createDirRecursive' inst
-  lEM $ make ["PREFIX=" <> inst, "install"] (Just path)
-
-- | Install an unpacked hls distribution (legacy).
-installHLSUnpackedLegacy :: (MonadReader env m, MonadFail m, HasLog env, MonadCatch m, MonadIO m)
-                         => FilePath      -- ^ Path to the unpacked hls bindist (where the executable resides)
-                         -> FilePath      -- ^ Path to install to
-                         -> Maybe Version -- ^ Nothing for isolated install
-                         -> Bool          -- ^ is it a force install
-                         -> Excepts '[CopyError, FileAlreadyExistsError] m ()
-installHLSUnpackedLegacy path inst mver' forceInstall = do
+installHLSUnpacked :: (MonadReader env m, MonadFail m, HasLog env, MonadCatch m, MonadIO m)
+              => FilePath      -- ^ Path to the unpacked hls bindist (where the executable resides)
+              -> FilePath      -- ^ Path to install to
+              -> Maybe Version -- ^ Nothing for isolated install
+              -> Bool          -- ^ is it a force install
+              -> Excepts '[CopyError, FileAlreadyExistsError] m ()
+installHLSUnpacked path inst mver' forceInstall = do
  lift $ logInfo "Installing HLS"
  liftIO $ createDirRecursive' inst

@@ -707,7 +692,7 @@ installHLSPostInst isoFilepath ver =
      -- create symlink if this is the latest version in a regular install
      hlsVers <- lift $ fmap rights getInstalledHLSs
      let lInstHLS = headMay . reverse . sort $ hlsVers
-      when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver SetHLSOnly
+      when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver


 -- | Installs hls binaries @haskell-language-server-\<ghcver\>@
@@ -740,8 +725,6 @@ installHLSBin :: ( MonadMask m
                    , TarDirDoesNotExist
                    , ArchiveResult
                    , FileAlreadyExistsError
-                    , ProcessError
-                    , DirNotEmpty
                    ]
                   m
                   ()
@@ -911,9 +894,9 @@ compileHLS targetHLS ghcs jobs ov isolateDir cabalProject cabalProjectLocal patc
      case isolateDir of
        Just isoDir -> do
          lift $ logInfo $ "isolated installing HLS to " <> T.pack isoDir
-          liftE $ installHLSUnpackedLegacy installDir isoDir Nothing True
+          liftE $ installHLSUnpacked installDir isoDir Nothing True
        Nothing -> do
-          liftE $ installHLSUnpackedLegacy installDir binDir (Just installVer) True
+          liftE $ installHLSUnpacked installDir binDir (Just installVer) True
    )

  liftE $ installHLSPostInst isolateDir installVer
@@ -1105,9 +1088,9 @@ setGHC ver sghc = do
  -- first delete the old symlinks (this fixes compatibility issues
  -- with old ghcup)
  case sghc of
-    SetGHCOnly -> liftE $ rmPlainGHC (_tvTarget ver)
-    SetGHC_XY  -> liftE $ rmMajorGHCSymlinks ver
-    SetGHC_XYZ -> liftE $ rmMinorGHCSymlinks ver
+    SetGHCOnly -> liftE $ rmPlain (_tvTarget ver)
+    SetGHC_XY  -> liftE $ rmMajorSymlinks ver
+    SetGHC_XYZ -> liftE $ rmMinorSymlinks ver

  -- for ghc tools (ghc, ghci, haddock, ...)
  verfiles <- ghcToolFiles ver
@@ -1126,10 +1109,9 @@ setGHC ver sghc = do

    -- create symlink
    forM_ mTargetFile $ \targetFile -> do
-      bindir <- ghcInternalBinDir ver
      let fullF = binDir </> targetFile  <> exeExt
-          fileWithExt = bindir </> file <> exeExt
-      destL <- binarySymLinkDestination fileWithExt
+          fileWithExt = file <> exeExt
+      destL <- lift $ ghcLinkDestination fileWithExt ver
      lift $ createLink destL fullF

  -- create symlink for share dir
@@ -1188,7 +1170,7 @@ unsetGHC :: ( MonadReader env m
            )
         => Maybe Text
         -> Excepts '[NotInstalled] m ()
-unsetGHC = rmPlainGHC
+unsetGHC = rmPlain


 -- | Set the @~\/.ghcup\/bin\/cabal@ symlink.
@@ -1240,52 +1222,35 @@ setHLS :: ( MonadReader env m
          , MonadUnliftIO m
          )
       => Version
-       -> SetHLS -- Nothing for legacy
       -> Excepts '[NotInstalled] m ()
-setHLS ver shls = do
-  whenM (lift $ not <$> hlsInstalled ver) (throwE (NotInstalled HLS (GHCTargetVersion Nothing ver)))
-
-  -- symlink destination
+setHLS ver = do
  Dirs {..} <- lift getDirs

-  -- first delete the old symlinks
-  case shls of
-    -- not for legacy
-    SetHLS_XYZ -> liftE $ rmMinorHLSSymlinks ver
-    -- legacy and new
-    SetHLSOnly -> liftE rmPlainHLS
+  -- Delete old symlinks, since these might have different ghc versions than the
+  -- selected version, so we could end up with stray or incorrect symlinks.
+  oldSyms <- lift hlsSymlinks
+  forM_ oldSyms $ \f -> do
+    lift $ logDebug $ "rm " <> T.pack (binDir </> f)
+    lift $ rmLink (binDir </> f)

-  case shls of
-    -- not for legacy
-    SetHLS_XYZ -> do
-      bins <- lift $ hlsInternalServerScripts ver Nothing
+  -- set haskell-language-server-<ghcver> symlinks
+  bins <- lift $ hlsServerBinaries ver Nothing
+  when (null bins) $ throwE $ NotInstalled HLS (GHCTargetVersion Nothing ver)

-      forM_ bins $ \f -> do
-        let fname = takeFileName f
-        destL <- binarySymLinkDestination f
-        let target = if "haskell-language-server-wrapper" `isPrefixOf` fname
-                     then fname <> "-" <> T.unpack (prettyVer ver) <> exeExt
-                     else fname <> "~" <> T.unpack (prettyVer ver) <> exeExt
-        lift $ createLink destL (binDir </> target)
+  forM_ bins $ \f -> do
+    let destL = f
+    let target = (<> exeExt) . head . splitOn "~" $ f
+    lift $ createLink destL (binDir </> target)

-    -- legacy and new
-    SetHLSOnly -> do
-      -- set haskell-language-server-<ghcver> symlinks
-      bins <- lift $ hlsServerBinaries ver Nothing
-      when (null bins) $ throwE $ NotInstalled HLS (GHCTargetVersion Nothing ver)
+  -- 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

-      forM_ bins $ \f -> do
-        let destL = f
-        let target = (<> exeExt) . head . splitOn "~" $ f
-        lift $ createLink destL (binDir </> target)
+  lift $ createLink destL wrapper

-      -- 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 warnAboutHlsCompatibility

-      lift $ createLink destL wrapper
-
-      lift warnAboutHlsCompatibility
+  pure ()


 unsetHLS :: ( MonadMask m
@@ -1755,14 +1720,14 @@ rmGHCVer ver = do
  -- this isn't atomic, order matters
  when isSetGHC $ do
    lift $ logInfo "Removing ghc symlinks"
-    liftE $ rmPlainGHC (_tvTarget ver)
+    liftE $ rmPlain (_tvTarget ver)

  lift $ logInfo "Removing ghc-x.y.z symlinks"
-  liftE $ rmMinorGHCSymlinks ver
+  liftE $ rmMinorSymlinks ver

  lift $ logInfo "Removing/rewiring ghc-x.y symlinks"
  -- first remove
-  handle (\(_ :: ParseError) -> pure ()) $ liftE $ rmMajorGHCSymlinks ver
+  handle (\(_ :: ParseError) -> pure ()) $ liftE $ rmMajorSymlinks ver
  -- then fix them (e.g. with an earlier version)

  lift $ logInfo $ "Removing directory recursively: " <> T.pack dir
@@ -1829,19 +1794,24 @@ rmHLSVer :: ( MonadMask m
 rmHLSVer ver = do
  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (GHCTargetVersion Nothing ver))

-  isHlsSet <- lift hlsSet
+  isHlsSet      <- lift hlsSet

-  liftE $ rmMinorHLSSymlinks ver
-  hlsDir <- ghcupHLSDir ver
-  recyclePathForcibly hlsDir
+  Dirs {..} <- lift getDirs
+
+  bins <- lift $ hlsAllBinaries ver
+  forM_ bins $ \f -> lift $ recycleFile (binDir </> f)

  when (Just ver == isHlsSet) $ do
    -- delete all set symlinks
-    rmPlainHLS
+    oldSyms <- lift hlsSymlinks
+    forM_ oldSyms $ \f -> do
+      let fullF = binDir </> f
+      lift $ logDebug $ "rm " <> T.pack fullF
+      lift $ rmLink fullF
    -- set latest hls
    hlsVers <- lift $ fmap rights getInstalledHLSs
    case headMay . reverse . sort $ hlsVers of
-      Just latestver -> setHLS latestver SetHLSOnly
+      Just latestver -> setHLS latestver
      Nothing        -> pure ()


@@ -2717,11 +2687,7 @@ whereIsTool tool ver@GHCTargetVersion {..} = do
    HLS -> do
      whenM (lift $ fmap not $ hlsInstalled _tvVersion)
        $ throwE (NotInstalled HLS (GHCTargetVersion Nothing _tvVersion))
-      ifM (lift $ isLegacyHLS _tvVersion)
-        (pure (binDir dirs </> "haskell-language-server-wrapper-" <> T.unpack (prettyVer _tvVersion) <> exeExt))
-        $ do
-          bdir <- lift $ ghcupHLSDir _tvVersion
-          pure (bdir </> "bin" </> "haskell-language-server-wrapper" <> exeExt)
+      pure (binDir dirs </> "haskell-language-server-wrapper-" <> T.unpack (prettyVer _tvVersion) <> exeExt)

    Stack -> do
      whenM (lift $ fmap not $ stackInstalled _tvVersion)
@@ -2834,31 +2800,21 @@ rmHLSNoGHC :: ( MonadReader env m
              , HasLog env
              , MonadIO m
              , MonadMask m
-              , MonadFail m
-              , MonadUnliftIO m
              )
-           => Excepts '[NotInstalled] m ()
+           => m ()
 rmHLSNoGHC = do
  Dirs {..} <- getDirs
  ghcs <- fmap rights getInstalledGHCs
  hlses <- fmap rights getInstalledHLSs
  forM_ hlses $ \hls -> do
    hlsGHCs <- fmap mkTVer <$> hlsGHCVersions' hls
-    let candidates = filter (`notElem` ghcs) hlsGHCs
-    if (length hlsGHCs - length candidates) <= 0
-    then rmHLSVer hls
-    else
-      forM_ candidates $ \ghc -> do
-        bins1 <- fmap (binDir </>) <$> hlsServerBinaries hls (Just $ _tvVersion ghc)
-        bins2 <- ifM (isLegacyHLS hls) (pure []) $ do
-          shs <- hlsInternalServerScripts hls (Just $ _tvVersion ghc)
-          bins <- hlsInternalServerBinaries hls (Just $ _tvVersion ghc)
-          libs <- hlsInternalServerLibs hls (_tvVersion ghc)
-          pure (shs ++ bins ++ libs)
-        forM_ (bins1 ++ bins2) $ \f -> do
+    forM_ hlsGHCs $ \ghc -> do 
+      when (ghc `notElem` ghcs) $ do
+        bins <- hlsServerBinaries hls (Just $ _tvVersion ghc)
+        forM_ bins $ \bin -> do
+          let f = binDir </> bin
          logDebug $ "rm " <> T.pack f
          rmFile f
-    pure ()


 rmCache :: ( MonadReader env m
--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -4,7 +4,7 @@
 {-# LANGUAGE FlexibleInstances     #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE TemplateHaskell       #-}


 {-|
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -484,10 +484,6 @@ data SetGHC = SetGHCOnly  -- ^ unversioned 'ghc'
            | SetGHC_XYZ  -- ^ ghc-x.y.z
            deriving (Eq, Show)

-data SetHLS = SetHLSOnly  -- ^ unversioned 'hls'
-            | SetHLS_XYZ  -- ^ haskell-language-server-a.b.c~x.y.z, where a.b.c is GHC version and x.y.z is HLS version
-            deriving (Eq, Show)
-

 data PlatformResult = PlatformResult
  { _platform      :: Platform
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -3,7 +3,7 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE ViewPatterns          #-}

@@ -125,34 +125,31 @@ import qualified Data.List.NonEmpty            as NE
    ------------------------


-- | Create a relative symlink destination for the binary directory,
-- given a target toolpath.
-binarySymLinkDestination :: ( MonadReader env m
-                            , HasDirs env
-                            , MonadThrow m
-                            , MonadIO m
-                            )
-                         => FilePath -- ^ the full toolpath
-                         -> m FilePath
-binarySymLinkDestination toolPath = do
+-- | The symlink destination of a ghc tool.
+ghcLinkDestination :: ( MonadReader env m
+                      , HasDirs env
+                      , MonadThrow m, MonadIO m)
+                   => FilePath -- ^ the tool, such as 'ghc', 'haddock' etc.
+                   -> GHCTargetVersion
+                   -> m FilePath
+ghcLinkDestination tool ver = do
  Dirs {..}  <- getDirs
-  toolPath' <- liftIO $ canonicalizePath toolPath
-  binDir' <- liftIO $ canonicalizePath binDir
-  pure (relativeSymlink binDir' toolPath')
+  ghcd <- ghcupGHCDir ver
+  pure (relativeSymlink binDir (ghcd </> "bin" </> tool))


 -- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
-rmMinorGHCSymlinks :: ( MonadReader env m
-                      , HasDirs env
-                      , MonadIO m
-                      , HasLog env
-                      , MonadThrow m
-                      , MonadFail m
-                      , MonadMask m
-                      )
-                   => GHCTargetVersion
-                   -> Excepts '[NotInstalled] m ()
-rmMinorGHCSymlinks tv@GHCTargetVersion{..} = do
+rmMinorSymlinks :: ( MonadReader env m
+                   , HasDirs env
+                   , MonadIO m
+                   , HasLog env
+                   , MonadThrow m
+                   , MonadFail m
+                   , MonadMask m
+                   )
+                => GHCTargetVersion
+                -> Excepts '[NotInstalled] m ()
+rmMinorSymlinks tv@GHCTargetVersion{..} = do
  Dirs {..}  <- lift getDirs

  files                         <- liftE $ ghcToolFiles tv
@@ -164,17 +161,17 @@ rmMinorGHCSymlinks tv@GHCTargetVersion{..} = do


 -- | Removes the set ghc version for the given target, if any.
-rmPlainGHC :: ( MonadReader env m
-              , HasDirs env
-              , HasLog env
-              , MonadThrow m
-              , MonadFail m
-              , MonadIO m
-              , MonadMask m
-              )
-           => Maybe Text -- ^ target
-           -> Excepts '[NotInstalled] m ()
-rmPlainGHC target = do
+rmPlain :: ( MonadReader env m
+           , HasDirs env
+           , HasLog env
+           , MonadThrow m
+           , MonadFail m
+           , MonadIO m
+           , MonadMask m
+           )
+        => Maybe Text -- ^ target
+        -> Excepts '[NotInstalled] m ()
+rmPlain target = do
  Dirs {..}  <- lift getDirs
  mtv                           <- lift $ ghcSet target
  forM_ mtv $ \tv -> do
@@ -190,17 +187,17 @@ rmPlainGHC target = do


 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorGHCSymlinks :: ( MonadReader env m
-                      , HasDirs env
-                      , MonadIO m
-                      , HasLog env
-                      , MonadThrow m
-                      , MonadFail m
-                      , MonadMask m
-                      )
-                   => GHCTargetVersion
-                   -> Excepts '[NotInstalled] m ()
-rmMajorGHCSymlinks tv@GHCTargetVersion{..} = do
+rmMajorSymlinks :: ( MonadReader env m
+                   , HasDirs env
+                   , MonadIO m
+                   , HasLog env
+                   , MonadThrow m
+                   , MonadFail m
+                   , MonadMask m
+                   )
+                => GHCTargetVersion
+                -> Excepts '[NotInstalled] m ()
+rmMajorSymlinks tv@GHCTargetVersion{..} = do
  Dirs {..}  <- lift getDirs
  (mj, mi) <- getMajorMinorV _tvVersion
  let v' = intToText mj <> "." <> intToText mi
@@ -213,62 +210,6 @@ rmMajorGHCSymlinks tv@GHCTargetVersion{..} = do
    lift $ hideError doesNotExistErrorType $ rmLink fullF


-- | Removes the minor HLS files, e.g. 'haskell-language-server-8.10.7~1.6.1.0'
-- and 'haskell-language-server-wrapper-1.6.1.0'.
-rmMinorHLSSymlinks :: ( MonadReader env m
-                      , HasDirs env
-                      , MonadIO m
-                      , HasLog env
-                      , MonadThrow m
-                      , MonadFail m
-                      , MonadMask m
-                      )
-                   => Version
-                   -> Excepts '[NotInstalled] m ()
-rmMinorHLSSymlinks ver = do
-  Dirs {..}  <- lift getDirs
-
-  hlsBins <- hlsAllBinaries ver
-  forM_ hlsBins $ \f -> do
-    let fullF = binDir </> f <> exeExt
-    lift $ logDebug ("rm -f " <> T.pack fullF)
-    -- on unix, this may be either a file (legacy) or a symlink
-    -- on windows, this is always a file... hence 'rmFile'
-    -- works consistently across platforms
-    lift $ rmFile fullF
-
-- | Removes the set HLS version, if any.
-rmPlainHLS :: ( MonadReader env m
-              , HasDirs env
-              , HasLog env
-              , MonadThrow m
-              , MonadFail m
-              , MonadIO m
-              , MonadMask m
-              )
-           => Excepts '[NotInstalled] m ()
-rmPlainHLS = do
-  Dirs {..}  <- lift getDirs
-
-  -- delete 'haskell-language-server-8.10.7'
-  hlsBins <- fmap (filter (\f -> not ("haskell-language-server-wrapper" `isPrefixOf` f) && ('~' `notElem` f)))
-    $ liftIO $ handleIO (\_ -> pure []) $ findFiles
-      binDir
-      (makeRegexOpts compExtended execBlank ([s|^haskell-language-server-.*$|] :: ByteString))
-  forM_ hlsBins $ \f -> do
-    let fullF = binDir </> f
-    lift $ logDebug ("rm -f " <> T.pack fullF)
-    if isWindows
-    then lift $ rmLink fullF
-    else lift $ rmFile fullF
-
-  -- 'haskell-language-server-wrapper'
-  let hlswrapper = binDir </> "haskell-language-server-wrapper" <> exeExt
-  lift $ logDebug ("rm -f " <> T.pack hlswrapper)
-  if isWindows
-  then lift $ hideError doesNotExistErrorType $ rmLink hlswrapper
-  else lift $ hideError doesNotExistErrorType $ rmFile hlswrapper
-


    -----------------------------------
@@ -412,8 +353,7 @@ cabalSet = do


 -- | Get all installed hls, by matching on
-- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@,
-- as well as @~\/.ghcup\/hls\/<\hlsver\>@
+-- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
 getInstalledHLSs :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
                 => m [Either FilePath Version]
 getInstalledHLSs = do
@@ -424,7 +364,7 @@ getInstalledHLSs = do
                   execBlank
                   ([s|^haskell-language-server-wrapper-.*$|] :: ByteString)
    )
-  legacy <- forM bins $ \f ->
+  forM bins $ \f ->
    case
          version . T.pack <$> (stripSuffix exeExt =<< stripPrefix "haskell-language-server-wrapper-" f)
      of
@@ -432,14 +372,6 @@ getInstalledHLSs = do
        Just (Left  _) -> pure $ Left f
        Nothing        -> pure $ Left f

-  hlsdir <- ghcupHLSBaseDir
-  fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ listDirectory hlsdir
-  new <- forM fs $ \f -> case parseGHCupHLSDir f of
-    Right r -> pure $ Right r
-    Left  _ -> pure $ Left f
-  pure (nub (new <> legacy))
-
-
 -- | Get all installed stacks, by matching on
 -- @~\/.ghcup\/bin/stack-<\stackver\>@.
 getInstalledStacks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
@@ -515,10 +447,6 @@ hlsInstalled ver = do
  vers <- fmap rights getInstalledHLSs
  pure $ elem ver vers

-isLegacyHLS :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
-isLegacyHLS ver = do
-  bdir <- ghcupHLSDir ver
-  not <$> liftIO (doesDirectoryExist bdir)


 -- Return the currently set hls version, if any.
@@ -590,7 +518,7 @@ hlsGHCVersions' v' = do
  pure . sortBy (flip compare) . rights $ vers


-- | Get all server binaries for an hls version from the ~/.ghcup/bin directory, if any.
+-- | Get all server binaries for an hls version, if any.
 hlsServerBinaries :: (MonadReader env m, HasDirs env, MonadIO m)
                  => Version
                  -> Maybe Version   -- ^ optional GHC version
@@ -611,44 +539,6 @@ hlsServerBinaries ver mghcVer = do
      )
    )

-- | Get all scripts for a hls version from the ~/.ghcup/hls/<ver>/bin directory, if any.
-- Returns the full path.
-hlsInternalServerScripts :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m)
-                          => Version
-                          -> Maybe Version   -- ^ optional GHC version
-                          -> m [FilePath]
-hlsInternalServerScripts ver mghcVer = do
-  dir <- ghcupHLSDir ver
-  let bdir = dir </> "bin"
-  fmap (bdir </>) . filter (\f -> maybe True (\gv -> ("-" <> T.unpack (prettyVer gv)) `isSuffixOf` f) mghcVer)
-    <$> liftIO (listDirectory bdir)
-
-- | Get all binaries for a hls version from the ~/.ghcup/hls/<ver>/lib/haskell-language-server-<ver>/bin directory, if any.
-- Returns the full path.
-hlsInternalServerBinaries :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadFail m)
-                          => Version
-                          -> Maybe Version   -- ^ optional GHC version
-                          -> m [FilePath]
-hlsInternalServerBinaries ver mghcVer = do
-  dir <- ghcupHLSDir ver
-  let regex = makeRegexOpts compExtended execBlank ([s|^haskell-language-server-.*$|] :: ByteString)
-  (Just bdir) <- fmap headMay $ liftIO $ expandFilePath [Left (dir </> "lib"), Right regex, Left "bin"]
-  fmap (bdir </>) . filter (\f -> maybe True (\gv -> ("-" <> T.unpack (prettyVer gv)) `isSuffixOf` f) mghcVer)
-    <$> liftIO (listDirectory bdir)
-
-- | Get all libraries for a hls version from the ~/.ghcup/hls/<ver>/lib/haskell-language-server-<ver>/lib/<ghc-ver>/
-- directory, if any.
-- Returns the full path.
-hlsInternalServerLibs :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadFail m)
-                      => Version
-                      -> Version   -- ^ GHC version
-                      -> m [FilePath]
-hlsInternalServerLibs ver ghcVer = do
-  dir <- ghcupHLSDir ver
-  let regex = makeRegexOpts compExtended execBlank ([s|^haskell-language-server-.*$|] :: ByteString)
-  (Just bdir) <- fmap headMay $ liftIO $ expandFilePath [Left (dir </> "lib"), Right regex, Left ("lib" </> T.unpack (prettyVer ghcVer))]
-  fmap (bdir </>) <$> liftIO (listDirectory bdir)
-

 -- | Get the wrapper binary for an hls version, if any.
 hlsWrapperBinary :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
@@ -679,6 +569,22 @@ hlsAllBinaries ver = do
  pure (maybeToList wrapper ++ hls)


+-- | Get the active symlinks for hls.
+hlsSymlinks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) => m [FilePath]
+hlsSymlinks = do
+  Dirs {..}  <- getDirs
+  oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+    binDir
+    (makeRegexOpts compExtended
+                   execBlank
+                   ([s|^haskell-language-server-.*$|] :: ByteString)
+    )
+  filterM
+    ( liftIO
+    . pathIsLink
+    . (binDir </>)
+    )
+    oldSyms



@@ -809,7 +715,7 @@ unpackToDir dfp av = do
      (untar . GZip.decompress =<< rf av)
    | ".tar.xz" `isSuffixOf` fn -> do
      filecontents <- liftE $ rf av
-      let decompressed = Lzma.decompressWith (Lzma.defaultDecompressParams { Lzma.decompressAutoDecoder= True }) filecontents
+      let decompressed = Lzma.decompress filecontents
      liftE $ untar decompressed
    | ".tar.bz2" `isSuffixOf` fn ->
      liftE (untar . BZip.decompress =<< rf av)
@@ -838,7 +744,7 @@ getArchiveFiles av = do
      (entries . GZip.decompress =<< rf av)
    | ".tar.xz" `isSuffixOf` fn -> do
      filecontents <- liftE $ rf av
-      let decompressed = Lzma.decompressWith (Lzma.defaultDecompressParams { Lzma.decompressAutoDecoder= True }) filecontents
+      let decompressed = Lzma.decompress filecontents
      liftE $ entries decompressed
    | ".tar.bz2" `isSuffixOf` fn ->
      liftE (entries . BZip.decompress =<< rf av)
@@ -903,16 +809,8 @@ getLatestBaseVersion av pvpVer =
    --[ Other ]--
    -------------

-- | Usually @~\/.ghcup\/ghc\/\<ver\>\/bin\/@
-ghcInternalBinDir :: (MonadReader env m, HasDirs env, MonadThrow m, MonadFail m, MonadIO m)
-                  => GHCTargetVersion
-                  -> m FilePath
-ghcInternalBinDir ver = do
-  ghcdir <- ghcupGHCDir ver
-  pure (ghcdir </> "bin")

-
-- | Get tool files from @~\/.ghcup\/ghc\/\<ver\>\/bin\/\*@
+-- | Get tool files from @~\/.ghcup\/bin\/ghc\/\<ver\>\/bin\/\*@
 -- while ignoring @*-\<ver\>@ symlinks and accounting for cross triple prefix.
 --
 -- Returns unversioned relative files without extension, e.g.:
@@ -922,10 +820,11 @@ ghcToolFiles :: (MonadReader env m, HasDirs env, MonadThrow m, MonadFail m, Mona
             => GHCTargetVersion
             -> Excepts '[NotInstalled] m [FilePath]
 ghcToolFiles ver = do
-  bindir <- ghcInternalBinDir ver
+  ghcdir <- lift $ ghcupGHCDir ver
+  let bindir = ghcdir </> "bin"

  -- fail if ghc is not installed
-  whenM (fmap not $ ghcInstalled ver)
+  whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
        (throwE (NotInstalled GHC ver))

  files <- liftIO (listDirectory bindir >>= filterM (doesFileExist . (bindir </>)))
@@ -980,28 +879,20 @@ makeOut args workdir = do
  executeOut mymake args workdir


-- | Try to apply patches in order. The order is determined by
-- a quilt series file (in the patch directory) if one exists,
-- else the patches are applied in lexicographical order.
-- Fails with 'PatchFailed' on first failure.
+-- | Try to apply patches in order. Fails with 'PatchFailed'
+-- on first failure.
 applyPatches :: (MonadReader env m, HasDirs env, HasLog env, MonadIO m)
             => FilePath   -- ^ dir containing patches
             -> FilePath   -- ^ dir to apply patches in
             -> Excepts '[PatchFailed] m ()
 applyPatches pdir ddir = do
-  let lexicographical = (fmap . fmap) (pdir </>) $ sort <$> findFiles
-        pdir
-        (makeRegexOpts compExtended
-                       execBlank
-                       ([s|.+\.(patch|diff)$|] :: ByteString)
-        )
-  let quilt = map (pdir </>) . lines <$> readFile (pdir </> "series")
-
-  patches <- liftIO $ quilt `catchIO` (\e ->
-    if isDoesNotExistError e || isPermissionError e then
-      lexicographical 
-    else throwIO e)
-  forM_ patches $ \patch' -> applyPatch patch' ddir
+  patches <- (fmap . fmap) (pdir </>) $ liftIO $ findFiles
+      pdir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|.+\.(patch|diff)$|] :: ByteString)
+      )
+  forM_ (sort patches) $ \patch' -> applyPatch patch' ddir


 applyPatch :: (MonadReader env m, HasDirs env, HasLog env, MonadIO m)
@@ -1258,19 +1149,3 @@ ensureDirectories (Dirs baseDir binDir cacheDir logsDir confDir trashDir) = do
 ghcBinaryName :: GHCTargetVersion -> String
 ghcBinaryName (GHCTargetVersion (Just t) _) = T.unpack (t <> "-ghc" <> T.pack exeExt)
 ghcBinaryName (GHCTargetVersion Nothing  _) = T.unpack ("ghc" <> T.pack exeExt)
-
-
-- | Does basic checks for isolated installs
-- Isolated Directory:
--   1. if it doesn't exist -> proceed
--   2. if it exists and is empty -> proceed
--   3. if it exists and is non-empty -> panic and leave the house
-installDestSanityCheck :: ( MonadIO m
-                          , MonadCatch m
-                          ) =>
-                          FilePath ->
-                          Excepts '[DirNotEmpty] m ()
-installDestSanityCheck isoDir = do
-  hideErrorDef [doesNotExistErrorType] () $ do
-    contents <- liftIO $ getDirectoryContentsRecursive isoDir
-    unless (null contents) (throwE $ DirNotEmpty isoDir)
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -20,11 +20,8 @@ module GHCup.Utils.Dirs
  , ghcupCacheDir
  , ghcupGHCBaseDir
  , ghcupGHCDir
-  , ghcupHLSBaseDir
-  , ghcupHLSDir
  , mkGhcupTmpDir
  , parseGHCupGHCDir
-  , parseGHCupHLSDir
  , relativeSymlink
  , withGHCupTmpDir
  , getConfigFilePath
@@ -49,7 +46,6 @@ import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource hiding (throwM)
 import           Data.Bifunctor
 import           Data.Maybe
-import           Data.Versions
 import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@@ -248,24 +244,6 @@ parseGHCupGHCDir :: MonadThrow m => FilePath -> m GHCTargetVersion
 parseGHCupGHCDir (T.pack -> fp) =
  throwEither $ MP.parse ghcTargetVerP "" fp

-parseGHCupHLSDir :: MonadThrow m => FilePath -> m Version
-parseGHCupHLSDir (T.pack -> fp) =
-  throwEither $ MP.parse version' "" fp
-
-- | ~/.ghcup/hls by default, for new-style installs.
-ghcupHLSBaseDir :: (MonadReader env m, HasDirs env) => m FilePath
-ghcupHLSBaseDir = do
-  Dirs {..}  <- getDirs
-  pure (baseDir </> "hls")
-
-- | Gets '~/.ghcup/hls/<hls-ver>' for new-style installs.
-ghcupHLSDir :: (MonadReader env m, HasDirs env, MonadThrow m)
-            => Version
-            -> m FilePath
-ghcupHLSDir ver = do
-  basedir <- ghcupHLSBaseDir
-  let verdir = T.unpack $ prettyVer ver
-  pure (basedir </> verdir)

 mkGhcupTmpDir :: ( MonadReader env m
                 , HasDirs env
@@ -335,7 +313,6 @@ useXDG :: IO Bool
 useXDG = isJust <$> lookupEnv "GHCUP_USE_XDG_DIRS"


-- | Like 'relpath'. Assumes the inputs are resolved in case of symlinks.
 relativeSymlink :: FilePath  -- ^ the path in which to create the symlink
                -> FilePath  -- ^ the symlink destination
                -> FilePath
--- a/lib/GHCup/Utils/File/Common.hs
+++ b/lib/GHCup/Utils/File/Common.hs
@@ -13,7 +13,7 @@ import           Data.Text               ( Text )
 import           Data.Void
 import           GHC.IO.Exception
 import           Optics                  hiding ((<|), (|>))
-import           System.Directory        hiding (findFiles)
+import           System.Directory
 import           System.FilePath
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
@@ -100,21 +100,6 @@ isInPath p = do
  else pure False


-- | Follows the first match in case of Regex.
-expandFilePath :: [Either FilePath Regex] -> IO [FilePath]
-expandFilePath = go ""
- where
-  go :: FilePath -> [Either FilePath Regex] -> IO [FilePath]
-  go p [] = pure [p]
-  go p (x:xs) = do
-    case x of
-      Left s -> go (p </> s) xs
-      Right regex -> do
-        fps <- findFiles p regex
-        res <- forM fps $ \fp -> go (p </> fp) xs
-        pure $ mconcat res
-
-
 findFiles :: FilePath -> Regex -> IO [FilePath]
 findFiles path regex = do
  contents <- listDirectory path
--- a/lib/GHCup/Utils/File/Posix.hs
+++ b/lib/GHCup/Utils/File/Posix.hs
@@ -35,7 +35,6 @@ import           Data.Sequence                  ( Seq, (|>) )
 import           Data.List
 import           Data.Word8
 import           GHC.IO.Exception
-import           System.IO                      ( stderr )
 import           System.IO.Error
 import           System.FilePath
 import           System.Directory
@@ -143,14 +142,14 @@ execLogged exe args chdir lfile env = do
  printToRegion :: Fd -> Fd -> Int -> MVar Bool -> Bool -> IO ()
  printToRegion fileFd fdIn size pState no_color = do
    -- init region
-    forM_ [1..size] $ \_ -> BS.hPut stderr "\n"
+    forM_ [1..size] $ \_ -> BS.putStr "\n"

    void $ flip runStateT mempty
      $ do
        handle
          (\(ex :: SomeException) -> do
            ps <- liftIO $ takeMVar pState
-            when ps (liftIO $ BS.hPut stderr (pos1 <> moveLineUp size <> clearScreen))
+            when ps (liftIO $ BS.putStr (pos1 <> moveLineUp size <> clearScreen))
            throw ex
          ) $ readTilEOF lineAction fdIn

@@ -185,7 +184,7 @@ execLogged exe args chdir lfile env = do
        Just (TP.Window _ w) -> do
          regs <- get
          liftIO $ forM_ (Sq.zip regs (Sq.fromList [0..(Sq.length regs - 1)])) $ \(bs, i) -> do
-              BS.hPut stderr
+              BS.putStr
              . overwriteNthLine (size - i)
              . trim w
              . blue
--- a/lib/GHCup/Utils/File/Windows.hs
+++ b/lib/GHCup/Utils/File/Windows.hs
@@ -196,8 +196,7 @@ execLogged exe args chdir lfile env = do
          then pure ()
          else do
            void $ BS.appendFile logFile some
-            -- subprocess stdout also goes to stderr for logging
-            void $ BS.hPut stderr some
+            void $ BS.hPut stdout some
            go
        

--- a/lib/GHCup/Utils/String/QQ.hs
+++ b/lib/GHCup/Utils/String/QQ.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE TemplateHaskell #-}

 {-|
 Module      : GHCup.Utils.String.QQ
--- a/lib/GHCup/Utils/Version/QQ.hs
+++ b/lib/GHCup/Utils/Version/QQ.hs
@@ -4,7 +4,7 @@
 {-# LANGUAGE DeriveLift         #-}
 {-# LANGUAGE FlexibleInstances  #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TemplateHaskellQuotes #-}
+{-# LANGUAGE TemplateHaskell    #-}


 {-|
--- a/scripts/bootstrap/bootstrap-haskell
+++ b/scripts/bootstrap/bootstrap-haskell
@@ -222,7 +222,8 @@ download_ghcup() {
            if freebsd-version | grep -E '^12.*' ; then
                freebsd_ver=12
            elif freebsd-version | grep -E '^13.*' ; then
-                freebsd_ver=13
+                # TODO: missing FreeBSD13 version
+                freebsd_ver=12
            else
                die "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues"
            fi
@@ -280,20 +281,7 @@ download_ghcup() {

 	# we may overwrite this in adjust_bashrc
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-		case ":\$PATH:" in
-		    *:"${GHCUP_BIN}":*)
-		        ;;
-		    *)
-		        export PATH="${GHCUP_BIN}:\$PATH"
-		        ;;
-		esac
-		case ":\$PATH:" in
-		    *:"\$HOME/.cabal/bin":*)
-		        ;;
-		    *)
-		        export PATH="\$HOME/.cabal/bin:\$PATH"
-		        ;;
-		esac
+		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF

 	# shellcheck disable=SC1090
@@ -381,38 +369,12 @@ adjust_bashrc() {
 	case $1 in
 		1)
 			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				case ":\$PATH:" in
-				    *:"${GHCUP_BIN}":*)
-				        ;;
-				    *)
-				        export PATH="${GHCUP_BIN}:\$PATH"
-				        ;;
-				esac
-				case ":\$PATH:" in
-				    *:"\$HOME/.cabal/bin":*)
-				        ;;
-				    *)
-				        export PATH="\$HOME/.cabal/bin:\$PATH"
-				        ;;
-				esac
+				export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 				EOF
 			;;
 		2)
 			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				case ":\$PATH:" in
-				    *:"\$HOME/.cabal/bin":*)
-				        ;;
-				    *)
-				        export PATH="\$PATH:\$HOME/.cabal/bin"
-				        ;;
-				esac
-				case ":\$PATH:" in
-				    *:"${GHCUP_BIN}":*)
-				        ;;
-				    *)
-				        export PATH="\$PATH:${GHCUP_BIN}"
-				        ;;
-				esac
+				export PATH="\$PATH:\$HOME/.cabal/bin:${GHCUP_BIN}"
 				EOF
 			;;
 		*) ;;
--- a/scripts/bootstrap/bootstrap-haskell.ps1
+++ b/scripts/bootstrap/bootstrap-haskell.ps1
@@ -29,11 +29,11 @@ param (
    [switch]$InstallStack,
    # Whether to install hls as well
    [switch]$InstallHLS,
-    # Specify the install root (default: 'C:\')
-    [string]$InstallDir,
    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
-    [string]$BootstrapUrl,
+    [string]$InstallDir,
    # Instead of installing a new MSys2, use an existing installation
+    [string]$BootstrapUrl,
+    # Specify the install root (default: 'C:\')
    [string]$ExistingMsys2Dir,
    # Specify the cabal root directory (default: '$InstallDir\cabal')
    [string]$CabalDir
--- a/scripts/update-sftp.sh
+++ b/scripts/update-sftp.sh
@@ -1,38 +0,0 @@
-#!/bin/bash
-
-url=$1
-ver=$2
-
-die() {
-    (>&2 printf "%s\\n" "$1")
-    exit 2
-}
-
-[ -z $url ] && die "no url set"
-[ -z $ver ] && die "no version set"
-
-sftp $url <<EOF
-cd ghcup
-
-rm aarch64-apple-darwin-ghcup
-rm aarch64-linux-ghcup
-rm armv7-linux-ghcup
-rm i386-linux-ghcup
-rm x86_64-apple-darwin-ghcup
-rm x86_64-linux-ghcup
-rm x86_64-mingw64-ghcup.exe
-rm x86_64-freebsd12-ghcup
-rm x86_64-freebsd13-ghcup
-
-symlink ${ver}/aarch64-apple-darwin-ghcup-${ver} aarch64-apple-darwin-ghcup
-symlink ${ver}/aarch64-linux-ghcup-${ver} aarch64-linux-ghcup
-symlink ${ver}/armv7-linux-ghcup-${ver} armv7-linux-ghcup
-symlink ${ver}/i386-linux-ghcup-${ver} i386-linux-ghcup
-symlink ${ver}/x86_64-apple-darwin-ghcup-${ver} x86_64-apple-darwin-ghcup
-symlink ${ver}/x86_64-freebsd12-ghcup-${ver} x86_64-freebsd12-ghcup
-symlink ${ver}/x86_64-freebsd13-ghcup-${ver} x86_64-freebsd13-ghcup
-symlink ${ver}/x86_64-linux-ghcup-${ver} x86_64-linux-ghcup
-symlink ${ver}/x86_64-mingw64-ghcup-${ver}.exe x86_64-mingw64-ghcup.exe
-EOF
-
-curl -X PURGE https://downloads.haskell.org/~ghcup/