Fix darwin aarch64 release

2021-07-11 17:28:35 +02:00
94 changed files with 3226 additions and 34351 deletions
--- a/.github/release.yaml
+++ b/.github/release.yaml
@@ -1,109 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  draft_release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          body: |
-            Changes in this Release
-            - First Change
-            - Second Change
-          draft: true
-          prerelease: false
-
-  release-mac:
-    name: Create Release for macOS
-    needs: draft_release
-    runs-on: ${{ matrix.os }}
-    env:
-      MACOSX_DEPLOYMENT_TARGET: 10.13
-    strategy:
-      matrix:
-        os:
-          - macOS-10.15
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - uses: haskell/actions/setup@v1.2
-        with:
-          ghc-version: 8.10.4
-          cabal-version: 3.4.0.0
-
-      - name: create ~/.local/bin
-        run: mkdir -p "$HOME/.local/bin"
-        shell: bash
-
-      - name: Add ~/.local/bin to PATH
-        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-        shell: bash
-
-      - name: Update cabal cache
-        run: cabal update
-        shell: bash
-
-      - name: Install cabal dependencies
-        run: cabal build --only-dependencies
-        shell: bash
-
-      - name: Build
-        run: cabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Install
-        run: cp "$(cabal list-bin exe:ghcup)" ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Strip
-        run: strip ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Run tests
-        run: cabal test --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" all
-        shell: bash
-
-      - name: Install git
-        run: brew install git
-
-      - name: set HOME
-        run: echo "HOME=$HOME" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Set ASSET_PATH
-        run: echo "ASSET_PATH=$HOME/.local/bin/ghcup" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }}
-          asset_path: ${{ env.ASSET_PATH }}
-          asset_name: ghcup-${{ matrix.os }}
-          asset_content_type: application/octet-stream
-
-      - if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: plan.json
-          path: ./dist-newstyle/cache/plan.json
-
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -1,109 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  draft_release:
-    name: Draft Release
-    runs-on: ubuntu-latest
-    outputs:
-      upload_url: ${{ steps.create_release.outputs.upload_url }}
-
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          body: |
-            Changes in this Release
-            - First Change
-            - Second Change
-          draft: true
-          prerelease: false
-
-  release-mac:
-    name: Create Release
-    needs: draft_release
-    runs-on: ${{ matrix.os }}
-    env:
-      MACOSX_DEPLOYMENT_TARGET: 10.13
-    strategy:
-      matrix:
-        os:
-          - macOS-10.15
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - uses: haskell/actions/setup@v1.2
-        with:
-          ghc-version: 8.10.4
-          cabal-version: 3.4.0.0
-
-      - name: create ~/.local/bin
-        run: mkdir -p "$HOME/.local/bin"
-        shell: bash
-
-      - name: Add ~/.local/bin to PATH
-        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
-        shell: bash
-
-      - name: Update cabal cache
-        run: cabal update
-        shell: bash
-
-      - name: Install cabal dependencies
-        run: cabal build --only-dependencies --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Build
-        run: cabal build --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Install
-        run: cp "$(cabal list-bin exe:ghcup)" ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Strip
-        run: strip ~/.local/bin/ghcup
-        shell: bash
-
-      - name: Run tests
-        run: cabal test --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" all
-        shell: bash
-
-      - name: Install git
-        run: brew install git
-
-      - name: set HOME
-        run: echo "HOME=$HOME" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Set ASSET_PATH
-        run: echo "ASSET_PATH=$HOME/.local/bin/ghcup" >> $GITHUB_ENV
-        shell: bash
-
-      - name: Upload Release Asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ needs.draft_release.outputs.upload_url }}
-          asset_path: ${{ env.ASSET_PATH }}
-          asset_name: ghcup-${{ matrix.os }}
-          asset_content_type: application/octet-stream
-
-      - if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: plan.json
-          path: ./dist-newstyle/cache/plan.json
-
--- a/.github/workflows/shimgen.yaml
+++ b/.github/workflows/shimgen.yaml
@@ -1,29 +0,0 @@
-name: Shimgen CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  build-shimgen:
-
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [windows-latest]
-
-    steps:
-    - uses: actions/checkout@v2
-    - uses: ilammy/msvc-dev-cmd@v1
-
-    - name: compile
-      run: cl /O1 scoop-better-shimexe/shim.c
-
-    - uses: actions/upload-artifact@v2
-      with:
-        name: shim.exe
-        path: shim.exe
-
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -14,14 +14,13 @@ variables:
 ############################################################

 .debian:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV"
+  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb9:$DOCKER_REV"
  tags:
    - x86_64-linux
  variables:
    OS: "LINUX"
    ARCH: "64"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-    CROSS: ""

 .alpine:64bit:
  image: "alpine:3.12"
@@ -49,7 +48,6 @@ variables:
    OS: "LINUX"
    ARCH: "ARM"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-  retry: 2

 .linux:aarch64:
  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
@@ -76,17 +74,9 @@ variables:
    ARCH: "ARM64"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"

-.freebsd13:
+.freebsd:
  tags:
-    - x86_64-freebsd13
-  variables:
-    OS: "FREEBSD"
-    ARCH: "64"
-    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-
-.freebsd12:
-  tags:
-    - x86_64-freebsd12
+    - x86_64-freebsd
  variables:
    OS: "FREEBSD"
    ARCH: "64"
@@ -99,7 +89,6 @@ variables:
    OS: "WINDOWS"
    ARCH: "64"
    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-  retry: 2

 .root_cleanup:
  after_script:
@@ -109,18 +98,13 @@ variables:
  script:
    - bash ./.gitlab/script/ghcup_version.sh
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.5"
  artifacts:
    expire_in: 2 week
    paths:
-      - test/golden
-      - dist-newstyle/cache/
+      - golden
    when: on_failure

-# .test_ghcup_scoop:
-  # script:
-    # - cl /O1 scoop-better-shimexe/shim.c
-
 .test_ghcup_version:linux:
  extends:
    - .test_ghcup_version
@@ -183,18 +167,10 @@ variables:
    runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1
    runInNixShell ./.gitlab/script/ghcup_version.sh 2>&1

-.test_ghcup_version:freebsd12:
+.test_ghcup_version:freebsd:
  extends:
    - .test_ghcup_version
-    - .freebsd12
-    - .root_cleanup
-  before_script:
-    - ./.gitlab/before_script/freebsd/install_deps.sh
-
-.test_ghcup_version:freebsd13:
-  extends:
-    - .test_ghcup_version
-    - .freebsd13
+    - .freebsd
    - .root_cleanup
  before_script:
    - ./.gitlab/before_script/freebsd/install_deps.sh
@@ -208,12 +184,6 @@ variables:
    - set CABAL_DIR="$CI_PROJECT_DIR/cabal"
    - bash ./.gitlab/before_script/windows/install_deps.sh

-# .test_ghcup_scoop:windows:
-  # extends:
-    # - .windows
-    # - .test_ghcup_scoop
-    # - .root_cleanup
-
 .release_ghcup:
  script:
    - bash ./.gitlab/script/ghcup_release.sh
@@ -221,11 +191,10 @@ variables:
    expire_in: 2 week
    paths:
      - out
-      - dist-newstyle/cache/
  only:
    - tags
  variables:
-    JSON_VERSION: "0.0.6"
+    JSON_VERSION: "0.0.5"

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

@@ -248,7 +217,7 @@ test:linux:bootstrap_script:
  script:
    - ./.gitlab/script/ghcup_bootstrap.sh
  variables:
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
  extends:
    - .debian
@@ -258,14 +227,14 @@ test:linux:bootstrap_script:
 test:windows:bootstrap_powershell_script:
  stage: test
  script:
-    - ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
+    - ./bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
  after_script:
    - "[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)"
    - "[Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)"
    - "[Environment]::SetEnvironmentVariable('CABAL_DIR', $null, [System.EnvironmentVariableTarget]::User)"
    - bash ./.gitlab/after_script.sh
  variables:
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
  extends:
    - .windows
@@ -273,104 +242,55 @@ test:windows:bootstrap_powershell_script:

 ######## linux test ########

-test:linux:
+test:linux:recommended:
  stage: test
  extends: .test_ghcup_version:linux
-  variables:
-    GHC_VERSION: "8.10.6"
-    CABAL_VERSION: "3.4.0.0"
-  needs: []
-
-test:linux:hls:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
-  variables:
-    GHC_VERSION: "8.10.7"
-    HLS_TARGET_VERSION: "1.4.0"
-    CABAL_VERSION: "3.6.0.0"
-  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_hls.sh
-
-test:linux:cross-armv7:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
  variables:
    GHC_VERSION: "8.10.5"
-    GHC_TARGET_VERSION: "8.10.6"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: "arm-linux-gnueabihf"
  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_cross.sh

-test:linux:git:hadrian:
+test:linux:latest:
  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
+  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.6"
-    GHC_GIT_TAG: "ghc-9.0.1-release"
-    GHC_GIT_VERSION: "9.0.1"
+    GHC_VERSION: "9.0.1"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
  needs: []
-  when: manual
-  allow_failure: true
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_git.sh
-

 ######## linux 32bit test ########

-test:linux:32bit:
+test:linux:recommended:32bit:
  stage: test
  extends: .test_ghcup_version:linux32
  variables:
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.2.0.0"
  needs: []

 ######## arm tests ########

-test:linux:armv7:
+test:linux:recommended:armv7:
  stage: test
  extends: .test_ghcup_version:armv7
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
  when: manual
  needs: []

-test:linux:aarch64:
+test:linux:recommended:aarch64:
  stage: test
  extends: .test_ghcup_version:aarch64
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
  when: manual
  needs: []

 ######## darwin test ########

-test:mac:
+test:mac:recommended:
  stage: test
  extends: .test_ghcup_version:darwin
  variables:
@@ -378,11 +298,19 @@ test:mac:
    CABAL_VERSION: "3.4.0.0"
  needs: []

-test:mac:aarch64:
+test:mac:latest:
+  stage: test
+  extends: .test_ghcup_version:darwin
+  variables:
+    GHC_VERSION: "9.0.1"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+test:mac:recommended:aarch64:
  stage: test
  extends: .test_ghcup_version:darwin:aarch64
  variables:
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
  needs: []
  allow_failure: true
@@ -390,19 +318,9 @@ test:mac:aarch64:

 ######## freebsd test ########

-test:freebsd12:
+test:freebsd:recommended:
  stage: test
-  extends: .test_ghcup_version:freebsd12
-  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  allow_failure: true # freebsd runners are unreliable
-  when: manual
-  needs: []
-
-test:freebsd13:
-  stage: test
-  extends: .test_ghcup_version:freebsd13
+  extends: .test_ghcup_version:freebsd
  variables:
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
@@ -412,24 +330,19 @@ test:freebsd13:

 ######## windows test ########

-test:windows:
+test:windows:recommended:
  stage: test
  extends: .test_ghcup_version:windows
  variables:
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
  needs: []

-# test:windows:scoop:
-  # stage: test
-  # extends: .test_ghcup_scoop:windows
-  # needs: []
-
 ######## linux release ########

 release:linux:64bit:
  stage: release
-  needs: ["test:linux"]
+  needs: ["test:linux:recommended", "test:linux:latest"]
  extends:
    - .alpine:64bit
    - .release_ghcup
@@ -437,13 +350,13 @@ release:linux:64bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"


 release:linux:32bit:
  stage: release
-  needs: ["test:linux:32bit"]
+  needs: ["test:linux:recommended:32bit"]
  extends:
    - .alpine:32bit
    - .release_ghcup
@@ -451,12 +364,12 @@ release:linux:32bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.2.0.0"

 release:linux:armv7:
  stage: release
-  needs: ["test:linux:armv7"]
+  needs: ["test:linux:recommended:armv7"]
  extends:
    - .linux:armv7
    - .release_ghcup
@@ -466,11 +379,10 @@ release:linux:armv7:
    ARTIFACT: "armv7-linux-ghcup"
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""

 release:linux:aarch64:
  stage: release
-  needs: ["test:linux:aarch64"]
+  needs: ["test:linux:recommended:aarch64"]
  extends:
    - .linux:aarch64
    - .release_ghcup
@@ -480,13 +392,12 @@ release:linux:aarch64:
    ARTIFACT: "aarch64-linux-ghcup"
    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
-    CROSS: ""

 ######## darwin release ########

 release:darwin:
  stage: release
-  needs: ["test:mac"]
+  needs: ["test:mac:recommended", "test:mac:latest"]
  extends:
    - .darwin
    - .release_ghcup
@@ -495,13 +406,13 @@ release:darwin:
    - ./.gitlab/before_script/darwin/install_deps.sh
  variables:
    ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
    MACOSX_DEPLOYMENT_TARGET: "10.7"

 release:darwin:aarch64:
  stage: release
-  needs: ["test:mac:aarch64"]
+  needs: ["test:mac:recommended:aarch64"]
  extends:
    - .darwin:aarch64
    - .release_ghcup
@@ -509,7 +420,7 @@ release:darwin:aarch64:
  script: |
    set -Eeuo pipefail
    function runInNixShell() {
-      time nix-shell $CI_PROJECT_DIR/.gitlab/shell.nix \
+      time nix-shell .gitlab/shell.nix \
        -I nixpkgs=https://github.com/angerman/nixpkgs/archive/75f7281738b.tar.gz \
        --argstr system "aarch64-darwin" \
        --pure \
@@ -528,7 +439,7 @@ release:darwin:aarch64:
    runInNixShell ./.gitlab/script/ghcup_release.sh 2>&1
  variables:
    ARTIFACT: "aarch64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
    MACOSX_DEPLOYMENT_TARGET: "10.7"
  allow_failure: true
@@ -536,33 +447,18 @@ release:darwin:aarch64:

 ######## freebsd release ########

-release:freebsd12:
+release:freebsd:
  stage: release
-  needs: ["test:freebsd12"]
+  needs: ["test:freebsd:recommended"]
  extends:
-    - .freebsd12
+    - .freebsd
    - .release_ghcup
    - .root_cleanup
  before_script:
    - ./.gitlab/before_script/freebsd/install_deps.sh
  variables:
    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.6"
-    CABAL_VERSION: "3.4.0.0"
-  allow_failure: true
-
-release:freebsd13:
-  stage: release
-  needs: ["test:freebsd13"]
-  extends:
-    - .freebsd13
-    - .release_ghcup
-    - .root_cleanup
-  before_script:
-    - ./.gitlab/before_script/freebsd/install_deps.sh
-  variables:
-    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"
  allow_failure: true

@@ -570,7 +466,7 @@ release:freebsd13:

 release:windows:
  stage: release
-  needs: ["test:windows"]
+  needs: ["test:windows:recommended"]
  extends:
    - .windows
    - .release_ghcup
@@ -579,7 +475,7 @@ release:windows:
    - bash ./.gitlab/before_script/windows/install_deps.sh
  variables:
    ARTIFACT: "x86_64-mingw64-ghcup"
-    GHC_VERSION: "8.10.6"
+    GHC_VERSION: "8.10.5"
    CABAL_VERSION: "3.4.0.0"

 ######## hlint ########
@@ -587,9 +483,15 @@ release:windows:
 hlint:
  stage: hlint
  extends:
-    - .debian
+    - .alpine:64bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  script:
-    - curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s -- -r lib/ test/
+    - ./.gitlab/script/hlint.sh
+  variables:
+    GHC_VERSION: "8.10.5"
+    CABAL_VERSION: "3.4.0.0"
+    JSON_VERSION: "0.0.4"
  allow_failure: true
  artifacts:
    expire_in: 2 week
--- a/.gitlab/before_script/darwin/install_deps.sh
+++ b/.gitlab/before_script/darwin/install_deps.sh
@@ -7,7 +7,7 @@ set -eux
 mkdir -p "${TMPDIR}"

 if [ $ARCH = 'ARM64' ] ; then
-	curl -sSfL https://downloads.haskell.org/~ghcup/aarch64-apple-darwin-ghcup > ./ghcup-bin
+	curl -sSfL https://downloads.haskell.org/~ghcup/0.1.15.1/aarch64-apple-darwin-ghcup-0.1.15.1 > ./ghcup-bin
 	chmod +x ghcup-bin
 else
 	curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -11,9 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-./ghcup-bin -v upgrade -i -f
-./ghcup-bin -v install ${GHC_VERSION}
-./ghcup-bin -v set ${GHC_VERSION}
-./ghcup-bin -v install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/linux/alpine/install_deps.sh
+++ b/.gitlab/before_script/linux/alpine/install_deps.sh
@@ -52,7 +52,3 @@ apk add --no-cache \
 	xz-dev \
 	ncurses-static

-if [ "${ARCH}" = "32" ] ; then
-	apk add --no-cache \
-		bsd-compat-headers
-fi
--- a/.gitlab/before_script/linux/install_deps.sh
+++ b/.gitlab/before_script/linux/install_deps.sh
@@ -7,21 +7,60 @@ set -eux
 mkdir -p "${TMPDIR}"

 sudo apt-get update -y
-sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https

-if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
-	sudo apt-get install -y gcc-arm-linux-gnueabihf
-	sudo dpkg --add-architecture armhf
-	sudo apt-get update -y
-	sudo apt-get install -y libncurses-dev:armhf
-fi
+case "${ARCH}" in
+	ARM*)
+		case "${ARCH}" in
+			"ARM")
+				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+				cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+				;;
+			"ARM64")
+				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+				cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+				;;
+			*)
+				exit 1 ;;
+		esac

-export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
-export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
-export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
-export BOOTSTRAP_HASKELL_VERBOSE=1
+		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin

-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
+		curl -O "${ghc_url}"
+		tar -xf ghc-*.tar.*
+		cd ghc-${GHC_VERSION}
+		./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+		make install
+		for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+			ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+		done
+		for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+			ln -s ${x##*/} ${x%-${GHC_VERSION}}
+		done
+		cd ..
+		rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+		unset x i

-rm "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
+		mkdir cabal-install
+		cd cabal-install
+		curl -O "${cabal_url}"
+		tar -xf cabal-install-*
+		mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+		cd ..
+		rm -rf cabal-install
+
+		;;
+	*) 
+		url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
+
+		curl -sSfL "${url}" > ./ghcup-bin
+		chmod +x ghcup-bin
+
+		./ghcup-bin upgrade -i -f
+		./ghcup-bin install ${GHC_VERSION}
+		./ghcup-bin set ${GHC_VERSION}
+		./ghcup-bin install-cabal ${CABAL_VERSION}
+
+		;;
+esac

--- a/.gitlab/before_script/windows/install_deps.sh
+++ b/.gitlab/before_script/windows/install_deps.sh
@@ -9,7 +9,7 @@ mkdir -p "${TMPDIR}" "${CABAL_DIR}"
 mkdir -p "$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin"

 CI_PROJECT_DIR=$(pwd)
-curl -o ghcup.exe https://downloads.haskell.org/~ghcup/x86_64-mingw64-ghcup.exe
+curl -o ghcup.exe https://downloads.haskell.org/~ghcup/0.1.15.1/x86_64-mingw64-ghcup-0.1.15.1.exe
 chmod +x ghcup.exe

 ./ghcup.exe install ${GHC_VERSION}
--- a/.gitlab/ghc-8.10.3-linux.files
+++ b/.gitlab/ghc-8.10.3-linux.files
--- a/.gitlab/ghc-8.10.3-windows.files
+++ b/.gitlab/ghc-8.10.3-windows.files
--- a/.gitlab/ghcup_env
+++ b/.gitlab/ghcup_env
@@ -1,11 +1,9 @@
 if [ "${OS}" = "WINDOWS" ] ; then
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export GHCUP_BIN="$CI_PROJECT_DIR/ghcup/bin"
-	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:$PATH"
+	export PATH="$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 else
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export GHCUP_BIN="$CI_PROJECT_DIR/.ghcup/bin"
-	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
+	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 fi
--- a/.gitlab/script/ghcup_bootstrap.sh
+++ b/.gitlab/script/ghcup_bootstrap.sh
@@ -24,7 +24,7 @@ export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
 export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
 export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION

-./scripts/bootstrap/bootstrap-haskell
+./bootstrap-haskell

 [ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]

--- a/.gitlab/script/ghcup_cross.sh
+++ b/.gitlab/script/ghcup_cross.sh
@@ -1,52 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-CI_PROJECT_DIR=$(pwd)
-
-ecabal() {
-	cabal "$@"
-}
-
-eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
-}
-
-git describe --always
-
-### build
-
-ecabal update
-
-ecabal build -w ghc-${GHC_VERSION}
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
-
-### cleanup
-
-rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-
-### manual cli based testing
-
-eghcup --numeric-version
-
-eghcup install ghc ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-
-cabal --version
-
-eghcup debug-info
-
-eghcup compile ghc -j $(nproc) -v ${GHC_TARGET_VERSION} -b ${GHC_VERSION} -x ${CROSS} -- --enable-unregisterised
-eghcup set ghc ${CROSS}-${GHC_TARGET_VERSION}
-
-[ `$(eghcup whereis ghc ${CROSS}-${GHC_TARGET_VERSION}) --numeric-version` = "${GHC_TARGET_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_git.sh
+++ b/.gitlab/script/ghcup_git.sh
@@ -1,52 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-CI_PROJECT_DIR=$(pwd)
-
-ecabal() {
-	cabal "$@"
-}
-
-eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
-}
-
-git describe --always
-
-### build
-
-ecabal update
-
-ecabal build -w ghc-${GHC_VERSION}
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
-
-### cleanup
-
-rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-
-### manual cli based testing
-
-eghcup --numeric-version
-
-eghcup install ghc ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-
-cabal --version
-
-eghcup debug-info
-
-eghcup compile ghc -j $(nproc) -g ${GHC_GIT_TAG} -b ${GHC_VERSION} -- --enable-unregisterised
-eghcup set ghc ${GHC_GIT_VERSION}
-
-[ `$(eghcup whereis ghc ${GHC_GIT_VERSION}) --numeric-version` = "${GHC_GIT_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_hls.sh
+++ b/.gitlab/script/ghcup_hls.sh
@@ -1,51 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-CI_PROJECT_DIR=$(pwd)
-
-ecabal() {
-	cabal "$@"
-}
-
-eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
-}
-
-git describe --always
-
-### build
-
-ecabal update
-
-ecabal build -w ghc-${GHC_VERSION}
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
-
-### cleanup
-
-rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-
-### manual cli based testing
-
-eghcup --numeric-version
-
-eghcup install ghc ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-
-cabal --version
-
-eghcup debug-info
-
-eghcup compile hls -j $(nproc) -v ${HLS_TARGET_VERSION} ${GHC_VERSION}
-
-[ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version` = "${HLS_TARGET_VERSION}" ] || [ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version | sed 's/.0$//'` = "${HLS_TARGET_VERSION}" ]
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
-
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -15,10 +15,14 @@ git describe
 # build
 ecabal update

+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)

 if [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
 	elif [ "${ARCH}" = "64" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	else
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -12,55 +12,38 @@ ecabal() {
 	cabal "$@"
 }

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

-if [ "${OS}" = "WINDOWS" ] ; then
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
-else
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-fi
-
 git describe --always

 ### build

 ecabal update

+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
+
 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 	ecabal haddock -w ghc-${GHC_VERSION} -ftui
 elif [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
-		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
-		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
+		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 	else
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
-
-		if [ "${ARCH}" = "64" ] ; then
-			# doctest
-			curl -sL https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-docspec/cabal-docspec-0.0.0.20210228_p1.tar.bz2 > cabal-docspec.tar.bz2
-			echo '3a10f6fec16dbd18efdd331b1cef5d2d342082da42f5b520726d1fa6a3990d12  cabal-docspec.tar.bz2' | sha256sum -c -
-			tar -xjf cabal-docspec.tar.bz2 cabal-docspec
-			mv cabal-docspec "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
-			rm -f cabal-docspec.tar.bz2
-			chmod a+x "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
-
-			cabal-docspec -XCPP -XTypeSynonymInstances -XOverloadedStrings -XPackageImports --check-properties
-		fi
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
@@ -87,30 +70,27 @@ fi

 ### cleanup

-rm -rf "${GHCUP_DIR}"
+if [ "${OS}" = "WINDOWS" ] ; then
+	rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
+else
+	rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+fi

 ### manual cli based testing


-ghcup-gen check -f data/metadata/ghcup-${JSON_VERSION}.yaml
+ghcup-gen check -f ghcup-${JSON_VERSION}.yaml

 eghcup --numeric-version

-eghcup install ghc ${GHC_VERSION}
-[ `$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version` = "${GHC_VERSION}" ]
-eghcup set ghc ${GHC_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
-eghcup unset cabal
-"$GHCUP_BIN"/cabal --version && exit || echo yes
-eghcup set cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
+eghcup install ${GHC_VERSION}
+eghcup set ${GHC_VERSION}
+eghcup install-cabal ${CABAL_VERSION}

 cabal --version

 eghcup debug-info

-# also test etags
 eghcup list
 eghcup list -t ghc
 eghcup list -t cabal
@@ -130,64 +110,36 @@ else
 	# test installing new ghc doesn't mess with currently set GHC
 	# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
 	if [ "${OS}" = "LINUX" ] ; then
-		eghcup --downloader=wget prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
-		if [ "${ARCH}" = "64" ] ; then
-			expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-linux.files" | sort)
-			actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find | sort)
-			[ "${actual}" = "${expected}" ]
-			unset actual expected
-		fi
-	elif [ "${OS}" = "WINDOWS" ] ; then
-		eghcup prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
-		expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-windows.files" | sort)
-		actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find | sort)
-		[ "${actual}" = "${expected}" ]
-		unset actual expected
-	else
-		eghcup prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
+		eghcup --downloader=wget install 8.10.3
+	else # test wget a bit
+		eghcup install 8.10.3
 	fi
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup --offline set 8.10.3
+	eghcup set 8.10.3
 	eghcup set 8.10.3
 	[ "$(ghc --numeric-version)" = "8.10.3" ]
 	eghcup set ${GHC_VERSION}
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup unset ghc
-    "$GHCUP_BIN"/ghc --numeric-version && exit || echo yes
-	eghcup set ${GHC_VERSION}
-	eghcup --offline rm 8.10.3
+	eghcup rm 8.10.3
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]

-
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
-		$(eghcup whereis hls) --version
+		haskell-language-server-wrapper --version

 		eghcup install stack
-		$(eghcup whereis stack) --version
+		stack --version
 	elif [ "${OS}" = "LINUX" ] ; then
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls
 			haskell-language-server-wrapper --version
-			eghcup unset hls
-			"$GHCUP_BIN"/haskell-language-server-wrapper --version && exit || echo yes

 			eghcup install stack
 			stack --version
-			eghcup unset hls
-			"$GHCUP_BIN"/stack --version && exit || echo yes
 		fi
 	fi
 fi

-# check that lazy loading works for 'whereis'
-cp "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak"
-echo '**' > "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
-eghcup whereis ghc $(ghc --numeric-version)
-mv -f "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"

 eghcup rm $(ghc --numeric-version)

@@ -199,60 +151,14 @@ if [ "${OS}" = "LINUX" ] ; then
 	fi
 fi

-sha_sum() {
-	if [ "${OS}" = "FREEBSD" ] ; then
-		sha256 "$@"
-	else
-		sha256sum "$@"
-	fi
-
-}
-
-# test etags
-rm -f "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-raw_eghcup -s https://www.haskell.org/ghcup/data/ghcup-${JSON_VERSION}.yaml list
-# snapshot yaml and etags file
-etag=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-# invalidate access time timer, which is 5minutes, so we re-download
-touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-# redownload same file with some newlines added
-raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
-# snapshot new yaml and etags file
-etag2=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha2=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-# compare
-[ "${etag}" != "${etag2}" ]
-[ "${sha}" != "${sha2}" ]
-# invalidate access time timer, which is 5minutes, but don't expect a re-download
-touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
-# this time, we expect the same hash and etag
-raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
-etag3=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
-sha3=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
-[ "${etag2}" = "${etag3}" ]
-[ "${sha2}" = "${sha3}" ]
-
-# test isolated installs
-eghcup install ghc -i "$(pwd)/isolated" 8.10.5
-[ "$(isolated/bin/ghc --numeric-version)" = "8.10.5" ]
-! eghcup install ghc -i "$(pwd)/isolated" 8.10.5
-if [ "${ARCH}" = "64" ] ; then
-	if [ "${OS}" = "LINUX" ] || [ "${OS}" = "WINDOWS" ] ; then
-		eghcup install cabal -i "$(pwd)/isolated" 3.4.0.0
-		[ "$(isolated/cabal --numeric-version)" = "3.4.0.0" ]
-		eghcup install stack -i "$(pwd)/isolated" 2.7.3
-		[ "$(isolated/stack --numeric-version)" = "2.7.3" ]
-		eghcup install hls -i "$(pwd)/isolated" 1.3.0
-		[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0" ] ||
-			[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0.0" ]
-	fi
-fi
-
 eghcup upgrade
 eghcup upgrade -f


 # nuke
 eghcup nuke
-[ ! -e "${GHCUP_DIR}" ]
+if [ "${OS}" = "WINDOWS" ] ; then
+	[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/ghcup" ]
+else
+	[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
+fi
--- a/.gitlab/shell.nix
+++ b/.gitlab/shell.nix
@@ -43,7 +43,6 @@

  # unconditionally add the MacOSX.sdk and TargetConditional.h
  export NIX_CFLAGS_COMPILE+=" -isystem /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include"
-  export NIX_LDFLAGS="-L/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib $NIX_LDFLAGS"

  '';

--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,10 @@
 jobs:
  include:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
    - os: osx
      osx_image: xcode10.1
      language: generic
@@ -10,16 +15,23 @@ jobs:
      language: generic
      env: ARTIFACT=x86_64-apple-darwin-10.14-ghcup

+  allow_failures:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+

 script: ".travis/build.sh"

 deploy:
  provider: releases
  api_key:
-    secure: "hT2od8Iy04tdFVuonPSWv0NX5hZDmv4al8Q0GbIWmviUetROuM7c6/MCHUcgyiw6H2L3pmH4F24GBYWpKBT3ZMbxrKXhZOZ3KPLXzlnuRlm1qymKqqwsJs3466bMftaiBr16rx1VpAuditN4A32oSmTFcQAJc84Bxn2WZ4t8hk9muS8YPyLhqg3/NxT6ob8dzNp9eS2cA0WODMb/fMzaMruRtepSK8JvuXb/SnTvaDcl9plmPzEa+eW54jwVsDps8ZpQMQlTtGIjYHIwTQ36/iLH4LoAvD7OEnB7qf753LOzmI/bvlB75xYGsLxe1qgpzPMjuG3AK0jb2KGSZCzyAyrbBFSQMIyC1gNKMtab3CohnA9WdQqAT1xrzPzA9zNw516G5Fn/z+t9Ek1f6L2OYO2hJfweNhWh+ChAIsOags2QBpqc0qjkwUS4wqxCWBdyVfgPTUoGelvjCfjQgypgIyLEHFvXt9rlj+kd97FY7nG3vxZrsvWTKKKT551OqUYX5zWTyvGR71jKyNst/p93Pg3DkRy31gHrGnG9zfNgN5tWxJqDd/suR/BAFTp0VtkFb8fR3ct7WMVeJXtE2+bKqxO5Fnocs1VjEm8pKPk7glnp0muu08kaO0h54wiSOCbk1RvO1KZtHue4wKWrHcI18dwW2WtzoBQ4P1lOSkS81UY="
+    secure: GQESg4TcYf3PQJRRaZV/kWS0hsF+OFnH2+EcwpgnIcfx4+aogMyprdh745KtBXe1FlFN1luKHksFjqceqhcg/xcNyeCJiSnLWMn4D/i4WUperEHseRBi5yZZCB1AvOjIlHrE4DS3a8pyEm1GV3G7CKY5Fu8jBjof2SnyENfd7fofhjtNHWmeFS+jBn8HRDf1YaSRYxzTw6uHLrPLsybfgQZVl7babMu/38Ghin0f5pz5OlNokzDxaubIYQHOZ7st7YndHJtBWWql/KualBWbMILy88dUVQBnbqQLP2P8d1ME8ILUjJVqz33HiRU0JzlEJyWfbvEjcJ6iD8M6n4nXTaxfu3i2UhhGsQ6SSBNKssMP4tji8nkNpMqG59wLQ/zhcetEm71fKkgJNrIMNllkqlWSo5K74IqqP9kiLg/qm8ipOJjui0gPk8tZXKcV+ztX1d1OVCapoLfiDM5l/0LLQXaTOXOV1x3e5LLQ/w2doNiH3eh5CV4II9dRu7owpaiiMBHMssmT0pH99jEeF6giHLKtt3y7l2GWoRLPdhsZZ54gxsaBxZt9GuypmkbNcr97CEnAVaWij5v0CF3w4rAWqy/tAxQpIDJOIOQBgmwG5WrBAKyKrFvEpBL5a8BPcRWJDvqKC83QeWpvPrEVdgJevC6ZN1MKzrb2SiPOwC2Kerc=
  file: $ARTIFACT
  on:
-    repo: hasufell/ghcup-hs
+    repo: haskell/ghcup-hs
    tags: true
  skip_cleanup: true
  draft: true
+
--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -18,8 +18,8 @@ ghcup set 8.10.4
 cabal update

 (
-       cd /tmp
-       cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
+	cd /tmp
+	cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
 )

 cabal build --constraint="zlib +static" --constraint="lzma +static" -ftui
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -1,46 +1,8 @@
 # Revision history for ghcup

-## 0.1.17 -- 2021-09-20
-
-* Add `--force` option to install/compile wrt [#210](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/210) by Arjun Kathuria
-* Implement compiling HLS from source wrt [#201](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/201)
-* Implement experimental GPG verification of the metadata file (see README) wrt [#263](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/236)
-* Add `ghcup unset` command wrt [#145](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/145)
-* Add `ghcup whereis bindir` etc wrt [#221](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/221)
-* Greatly reduce dependency footprint wrt [#212](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/212)
-* Add `ghcup --plan-json`
-* Improve `--patchdir` option for GHC compilation wrt [#226](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/226)
-* Try to improve logging and failure modes, especially during downloads
-* Add descriptive warnings when HLS and GHC versions are incompatible
-* Improve curl header parsing wrt [#213](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/213)
-
-## 0.1.16.2 -- 2021-08-12
-
-* Add isolated installations wrt [#141](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/141) by Arjun Kathuria
-* Implement config cli MVP wrt [#134](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/134) by Oleksii Dorozhkin
-* Fix `ghcup compile ghc --flavor`
-* Fix minor installation bug causing increased disk space wrt [#139](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/139)
-* Improved error handling wrt [#136](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/136)
-* Various improvements to metadata download when using `file://` and `--offline` wrt [#137](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/137)
-
-## 0.1.16.1 -- 2021-07-29
+## 0.1.16 -- ????-??-??

 * Add 'nuke' subcommand wrt [#135](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/135), implemented by Arjun Kathuria
-* Add uninstallation powershell script on windows wrt [#150](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/150)
-* Improve logging
-* Fix building GHC cross compiler wrt [#180](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/180)
-* Allow to use hadrian as build system (for git based versions only) wrt [#35](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/35)
-* Allow passing `--flavor` to `ghcup compile ghc`
-* Support new GHC `bin/` directory format wrt [ghc/ghc#20074](https://gitlab.haskell.org/ghc/ghc/-/issues/20074#note_363720)
-* Implement `whereis` subcommand wrt [#173](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/173)
-* Add `--offline` switch and `prefetch` subcommand wrt [#186](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/186)
-* Implement ETAGs hashing for metadata downloads to speed up `ghcup list` wrt [#193](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/193)
-* Avoid unnecessary fetching of ghcup metadata in some commands
-* Avoid unnecessary update checks for some commands
-* Preserve mtimes on unpacked GHC tarballs on windows wrt [#187](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/187), fixing issues with `ghc-pkg`
-* Fix lesser bug in `ghcup list` for stray stack versions wrt [#183](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/183)
-* Major redo on how file removal on windows works, avoiding partial removals etc, wrt [#165](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/165)
-* Improve ghcup tui for screen readers wrt [github/#4](https://github.com/haskell/ghcup-hs/pull/4), thanks to Mario Lang

 ## 0.1.15.2 -- 2021-06-13

--- a/docs/HACKING.md
+++ b/docs/HACKING.md
--- a/README.md
+++ b/README.md
@@ -6,28 +6,18 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p

 ## Table of Contents

-[![Join the chat at Libera.chat](https://img.shields.io/badge/chat-on%20libera%20IRC-brightgreen.svg)](https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup)
-[![Join the chat at Matrix.org](https://img.shields.io/matrix/haskell-tooling:matrix.org?label=chat%20on%20matrix.org)](https://app.element.io/#/room/#haskell-tooling:matrix.org)
-[![Join the chat at Discord](https://img.shields.io/discord/280033776820813825?label=chat%20on%20discord)](https://discord.gg/pKYf3zDQU7)
-[![Join the chat at https://gitter.im/haskell/ghcup](https://badges.gitter.im/haskell/ghcup.svg)](https://gitter.im/haskell/ghcup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-<a href="https://opencollective.com/ghcup#category-CONTRIBUTE"><img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" alt="Donate" width="150"></a>
-
   * [Installation](#installation)
-     * [Supported platforms](#supported-platforms)
+     * [Simple bootstrap](#simple-bootstrap)
     * [Manual install](#manual-install)
     * [Vim integration](#vim-integration)
   * [Usage](#usage)
     * [Configuration](#configuration)
-     * [GPG verification](#gpg-verification)
     * [Manpages](#manpages)
     * [Shell-completion](#shell-completion)
-     * [Compiling GHC from source](#compiling-ghc-from-source)
+     * [Cross support](#cross-support)
     * [XDG support](#xdg-support)
     * [Env variables](#env-variables)
     * [Installing custom bindists](#installing-custom-bindists)
-     * [Isolated Installs](#isolated-installs)
-     * [CI](#ci)
-     * [Tips and tricks](#tips-and-tricks)
   * [Design goals](#design-goals)
   * [How](#how)
   * [Known users](#known-users)
@@ -36,59 +26,9 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p

 ## Installation

-Most users should follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/).
-Advanced users may want to perform a [manual installation](#manual-install).
+### Simple bootstrap

-### Supported platforms
-
-This list may not be exhaustive and specifies support for bindists only.
-
-| Platform | Architecture | ghcup | GHC | cabal | HLS | stack | 
-| ------ | ------ | ------ | ------ | ------ | ------ | ------ |
-| Windows 7 | amd64 | ❔ | ✅ | ✅ | ✅ | ✅ |
-| Windows 10 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2016 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2019 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows Server 2022 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Windows WSL1 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
-| Windows WSL2 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| MacOS >=13 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| MacOS <13 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
-| MacOS | aarch64 | ✅ | ✅ | ✅ | ⚠️ | ❌ |
-| FreeBSD | amd64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-| Linux generic | x86 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Linux generic | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
-| Linux generic | aarch64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-| Linux generic | armv7 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
-
-#### Windows 7
-
-May or may not work, several issues:
-
-* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/140
-* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/197
-
-#### WSL1
-
-Unsupported. GHC may or may not work. Upgrade to WSL2.
-
-#### MacOS <13
-
-Not supported. Would require separate binaries, since >=13 binaries are incompatible.
-Please upgrade.
-
-#### MacOS aarch64
-
-HLS bindists are still experimental. Stack is theoretically supported, but has no binaries yet.
-
-#### FreeBSD
-
-Lacks some upstream bindists and may need compat libs, since most bindists are built on FreeBSD-12.
-HLS bindists are experimental.
-
-#### Linux ARMv7/AARCH64
-
-Lower availability of bindists. HLS only has experimental ones. Stack not supported currently.
+Follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/)

 ### Manual install

@@ -143,38 +83,10 @@ handles your haskell packages and can demand that [a specific version](https://c
 ### Configuration

 A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
-explaining all possible configurations can be found in this repo: [config.yaml](./data/config.yaml).
+explaining all possible configurations can be found in this repo: [config.yaml](./config.yaml).

 Partial configuration is fine. Command line options always override the config file settings.

-### GPG verification
-
-GHCup supports verifying the GPG signature of the metadata file. The metadata file then contains SHA256 hashes of all downloads, so
-this is cryptographically secure.
-
-First, obtain the gpg key:
-
-```sh
-gpg --batch --keyserver keys.openpgp.org --recv-keys 7784930957807690A66EBDBE3786C5262ECB4A3F
-```
-
-Then verify the gpg key in one of these ways:
-
-1. find out where I live and visit me to do offline key signing
-2. figure out my mobile phone number and call me to verify the fingerprint
-3. more boring: contact me on Libera IRC (`maerwald`) and verify the fingerprint
-
-Once you've verified the key, you have to figure out if you trust me.
-
-If you trust me, then you can configure gpg in `~/.ghcup/config.yaml`:
-
-```yml
-gpg-setting: GPGLax # GPGStrict | GPGLax | GPGNone
-```
-
-In `GPGStrict` mode, ghcup will fail if verification fails. In `GPGLax` mode it will just print a warning.
-You can also pass the mode via `ghcup --gpg <strict|lax|none>`.
-
 ### Manpages

 For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
@@ -182,26 +94,14 @@ For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man`

 ### Shell-completion

-Shell completions are in [scripts/shell-completions](./scripts/shell-completions) directory of this repository.
+Shell completions are in `shell-completions`.

 For bash: install `shell-completions/bash`
 as e.g. `/etc/bash_completion.d/ghcup` (depending on distro)
 and make sure your bashrc sources the startup script
 (`/usr/share/bash-completion/bash_completion` on some distros).

-### Compiling GHC from source
-
-Compiling from source is supported for both source tarballs and arbitrary git refs. See `ghcup compile ghc --help`
-for a list of all available options.
-
-If you need to overwrite the existing `build.mk`, check the default files
-in [data/build_mk](./data/build_mk), copy them somewhere, adjust them and
-pass `--config path/to/build.mk` to `ghcup compile ghc`.
-Common `build.mk` options are explained [here](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/using#build-configuration).
-
-Make sure your system meets all the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/preparation).
-
-#### Cross support
+### Cross support

 ghcup can compile and install a cross GHC for any target. However, this
 requires that the build host has a complete cross toolchain and various
@@ -235,7 +135,6 @@ This is the complete list of env variables that change GHCup behavior:
 * `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
 * `GHCUP_CURL_OPTS`: additional options that can be passed to curl
 * `GHCUP_WGET_OPTS`: additional options that can be passed to wget
-* `GHCUP_GPG_OPTS`: additional options that can be passed to gpg
 * `GHCUP_SKIP_UPDATE_CHECK`: Skip the (possibly annoying) update check when you run a command
 * `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup

@@ -255,160 +154,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).

-### Isolated installs
-
-Ghcup also enables you to install a tool (GHC, Cabal, HLS, Stack) at an isolated location of your choosing.
-These installs, as the name suggests, are separate from your main installs and DO NOT conflict with them.
-
-
- No symlinks are made to these isolated installed tools, you'd have to manually point to them wherever you intend to use them.
-
- These installs, can also NOT be deleted from ghcup, you'd have to go and manually delete these.
-
-You need to use the `--isolate` or `-i` flag followed by the directory path.
-
-Examples:-
-
-1. install an isolated GHC version at location /home/user/isolated_dir/ghc/  
-   - `ghcup install ghc 8.10.5 --isolate /home/user/isolated_dir/ghc`
-
-2. isolated install Cabal at a location you desire  
-   - `ghcup install cabal --isolate /home/username/my_isolated_dir/`
-
-3. do an isolated install with a custom bindist  
-   - `ghcup install ghc --isolate /home/username/my_isolated_dir/ -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
-
-4. isolated install HLS  
-   - `ghcup install hls --isolate /home/username/dir/hls/`
-
-5. you can even compile ghc to an isolated location.  
-   - `ghcup compile ghc -j 4 -v 9.0.1 -b 8.10.5 -i /home/username/my/dir/ghc` 
-   ---  
-
-### CI
-
-On windows, ghcup can be installed automatically on a CI runner like so:
-
-```ps
-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:\"
-```
-
-On linux/darwin/freebsd, run the following on your runner:
-
-```sh
-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
-```
-
-This will just install `ghcup` and on windows additionally `msys2`.
-
-#### Example github workflow
-
-On github workflows you can use 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
-```
-   
-### Tips and tricks
-
-#### with_ghc wrapper (e.g. for HLS)
-
-Due to some HLS [bugs](https://github.com/mpickering/hie-bios/issues/194) it's necessary that the `ghc` in PATH
-is the one defined in `cabal.project`. With some simple shell functions, we can start our editor with the appropriate
-path prepended.
-
-For bash, in e.g. `~/.bashrc` define:
-
-```sh
-with_ghc() {
-  local np=$(ghcup --offline whereis -d ghc $1 || { ghcup --cache install ghc $1 && ghcup whereis -d ghc $1 ;})
-  if [ -e "${np}" ] ; then
-    shift
-    PATH="$np:$PATH" "$@"
-  else
-    >&2 echo "Cannot find or install GHC version $1"
-    return 1
-  fi
-}
-```
-
-For fish shell, in e.g. `~/.config/fish/config.fish` define:
-
-```fish
-function with_ghc
-  set --local np (ghcup --offline whereis -d ghc $argv[1] ; or begin ghcup --cache install ghc $argv[1] ; and ghcup whereis -d ghc $argv[1] ; end)
-  if test -e "$np"
-    PATH="$np:$PATH" $argv[2..-1]
-  else
-    echo "Cannot find or install GHC version $argv[1]" 1>&2
-    return 1
-  end
-end
-```
-
-Then start a new shell and issue:
-
-```sh
-# replace 'code' with your editor
-with_ghc 8.10.5 code path/to/haskell/source
-```
-
-Cabal and HLS will now see `8.10.5` as the primary GHC, without the need to
-run `ghcup set` all the time when switching between projects.
-
 ## Design goals

 1. simplicity
@@ -437,13 +182,8 @@ In addition this script can also install `cabal-install`.

 ## Known users

-* Github actions:
-	- [actions/virtual-environments](https://github.com/actions/virtual-environments)
-	- [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
-* mirrors:
-	- [sjtug](https://mirror.sjtu.edu.cn/docs/ghcup)
-* tools:
-	- [vabal](https://github.com/Franciman/vabal)
+* Github action [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
+* [vabal](https://github.com/Franciman/vabal)

 ## Known problems

@@ -490,110 +230,16 @@ to figure out whether you have the correct toolchain and
 the correct dependencies. Refer to [the official docs](https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Linux)
 on how to prepare your environment for building GHC.

-### Stack support
-
-There may be a number of bugs when trying to make ghcup installed GHC versions work with stack,
-such as:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/188
-
-Further, stack's upgrade procedure may break/confuse ghcup. There are a number of integration
-issues discussed here:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/153
-
-### Windows support
-
-Windows support is in early stages. Since windows doesn't support symbolic links properly,
-ghcup uses a [shimgen wrapper](https://github.com/71/scoop-better-shimexe). It seems to work
-well, but there may be unknown issues with that approach.
-
-Windows 7 and Powershell 2.0 aren't well supported at the moment, also see:
-
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/140
- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/197
-
 ## FAQ

-### Why reimplement stack?
+1. Why reimplement stack?

-GHCup is not a reimplementation of stack. The only common part is automatic installation of GHC,
-but even that differs in scope and design.
+ghcup is not a reimplementation of stack. The only common part is automatic installation of GHC, but even that differs in scope and design.

-### Why should I use ghcup over stack?
+2. Why not support windows?

-GHCup is not a replacement for stack. Instead, it supports installing and managing stack versions.
-It does the same for cabal, GHC and HLS. As such, It doesn't make a workflow choice for you.
+We do.

-### Why should I let ghcup manage stack?
+3. Why the haskell reimplementation?

-You don't need to. However, some users seem to prefer to have a central tool that manages cabal and stack
-at the same time. Additionally, it can allow better sharing of GHC installation across these tools.
-Also see:
-
-* https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
-* https://github.com/commercialhaskell/stack/pull/5585
-
-### Why does ghcup not use stack code?
-
-Oddly, this question has been asked a couple of times. For the curious, here are a few reasons:
-
-1. GHCup started as a shell script. At the time of rewriting it in Haskell, the authors didn't even know that stack exposes *some* of its [installation API](https://hackage.haskell.org/package/stack-2.5.1.1/docs/Stack-Setup.html)
-2. Even if they did, it doesn't seem it would have satisfied their needs
-	  - it didn't support cabal installation, which was the main motivation behind GHCup back then
-	  - depending on a codebase as big as stack for a central part of one's application without having a short contribution pipeline would likely have caused stagnation or resulted in simply copy-pasting the relevant code in order to adjust it
-	  - it's not clear how GHCup would have been implemented with the provided API. It seems the codebases are fairly different. GHCup does a lot of symlink handling to expose a central `bin/` directory that users can easily put in PATH, without having to worry about anything more. It also provides explicit removal functionality, GHC cross-compilation, a TUI, etc etc.
-3. GHCup is built around unix principles and supposed to be simple.
-
-### Why not unify...
-
-#### ...stack and Cabal and do away with standalone installers
-
-GHCup is not involved in such decisions. cabal-install and stack might have a
-sufficiently different user experience to warrant having a choice.
-
-#### ...installer implementations and have a common library
-
-This sounds like an interesting goal. However, GHC installation isn't a hard engineering problem
-and the shared code wouldn't be too exciting. For such an effort to make sense, all involved
-parties would need to collaborate and have a short pipeline to get patches in.
-
-It's true this would solve the integration problem, but following unix principles, we can
-do similar via **hooks**. Both cabal and stack can support installation hooks. These hooks
-can then call into ghcup or anything else, also see:
-
-* https://github.com/haskell/cabal/issues/7394
-* https://github.com/commercialhaskell/stack/pull/5585
-
-#### ...installers (like, all of it)
-
-So far, there hasn't been an **open** discussion about this. Is this even a good idea?
-Sometimes projects converge eventually if their overlap is big enough, sometimes they don't.
-
-While unification sounds like a simplification of the ecosystem, it also takes away choice.
-Take `curl` and `wget` as an example.
-
-How bad do we need this?
-
-### Why not support windows?
-
-Windows is supported since GHCup version 0.1.15.1.
-
-### Why the haskell reimplementation?
-
-GHCup started as a portable posix shell script of maybe 50 LOC. GHC installation itself can be carried out in
-about ~3 lines of shell code (download, unpack , configure+make install). However, much convenient functionality
-has been added since, as well as ensuring that all operations are safe and correct. The shell script ended up with
-over 2k LOC, which was very hard to maintain.
-
-The main concern when switching from a portable shell script to haskell was platform/architecture support.
-However, ghcup now re-uses GHCs CI infrastructure and as such is perfectly in sync with all platforms that
-GHC supports.
-
-### Is GHCup affiliated with the Haskell Foundation?
-
-There has been some collaboration: Windows and Stack support were mainly requested by the Haskell Foundation
-and those seemed interesting features to add.
-
-Other than that, GHCup is dedicated only to its users and is supported by haskell.org through hosting and CI
-infrastructure.
+:-)
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -0,0 +1,19 @@
+# RELEASING
+
+1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version.
+
+2. Update version in ghcup.cabal
+
+3. Add ChangeLog entry
+
+4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
+
+5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
+
+6. Download release artifacts and upload them `downloads.haskell.org/ghcup`
+
+7. Add release artifacts to yaml file (see point 4.)
+
+8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
+
+9. Update bootstrap-haskell and symlinks on `downloads.haskell.org/ghcup`
--- a/docs/TODO.md
+++ b/docs/TODO.md
--- a/app/ghcup-gen/Main.hs
+++ b/app/ghcup-gen/Main.hs
@@ -11,33 +11,22 @@
 module Main where

 import           GHCup.Types
-import           GHCup.Errors
-import           GHCup.Platform
-import           GHCup.Utils.Dirs
-import           GHCup.Utils.Logger
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.Logger

-import           Control.Monad.Trans.Reader     ( runReaderT )
-import           Control.Monad.IO.Class
 import           Data.Char                      ( toLower )
-import           Data.Maybe
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
 import           Options.Applicative     hiding ( style )
-import           Haskus.Utils.Variant.Excepts
 import           System.Console.Pretty
-import           System.Environment
 import           System.Exit
-import           System.IO                      ( stderr )
+import           System.IO                      ( stdout )
 import           Text.Regex.Posix
 import           Validate
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )

-import qualified Data.Text.IO                  as T
-import qualified Data.Text                     as T
 import qualified Data.ByteString               as B
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y


 data Options = Options
@@ -116,29 +105,10 @@ com = subparser

 main :: IO ()
 main = do
-  no_color <- isJust <$> lookupEnv "NO_COLOR"
-  let loggerConfig = LoggerConfig { lcPrintDebug  = True
-                                  , consoleOutter = T.hPutStr stderr
-                                  , fileOutter    = \_ -> pure ()
-                                  , fancyColors   = not no_color
-                                  }
-  dirs <- liftIO getAllDirs
-  let leanAppstate = LeanAppState (Settings True False Never Curl True GHCupURL False GPGNone False) dirs defaultKeyBindings loggerConfig
-
-  pfreq <- (
-    flip runReaderT leanAppstate . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] $ platformRequest
-    ) >>= \case
-            VRight r -> pure r
-            VLeft e -> do
-              flip runReaderT leanAppstate $ logError $ T.pack $ prettyShow e
-              liftIO $ exitWith (ExitFailure 2)
-
-  let appstate = AppState (Settings True False Never Curl True GHCupURL False GPGNone False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq loggerConfig
-
  _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
    >>= \Options {..} -> case optCommand of
-          ValidateYAML vopts -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validate dl m)
-          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validateTarballs tarballFilter dl m)
+          ValidateYAML vopts -> withValidateYamlOpts vopts validate
+          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (validateTarballs tarballFilter)
  pure ()

 where
@@ -150,8 +120,8 @@ main = do
    ValidateYAMLOpts { vInput = Just (FileInput file) } ->
      B.readFile file >>= valAndExit f
  valAndExit f contents = do
-    (GHCupInfo _ av gt) <- case Y.decode1Strict contents of
+    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
      Right r -> pure r
-      Left  (_, e) -> die (color Red $ show e)
-    f av gt
+      Left  e -> die (color Red $ show e)
+    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
      >>= exitWith
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -5,24 +5,29 @@
 {-# LANGUAGE TemplateHaskell  #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE ViewPatterns     #-}
-{-# LANGUAGE OverloadedStrings #-}

 module Validate where

 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
+import           GHCup.Platform
 import           GHCup.Types
 import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.Logger
 import           GHCup.Utils.Version.QQ

+#if defined(TAR)
+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
+import           Control.Monad.Logger
 import           Control.Monad.Reader.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Control.Monad.Trans.Reader     ( runReaderT )
@@ -32,15 +37,18 @@ import           Control.Monad.Trans.Resource   ( runResourceT
 import           Data.Containers.ListUtils      ( nubOrd )
 import           Data.IORef
 import           Data.List
+import           Data.String.Interpolate
 import           Data.Versions
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           System.FilePath
 import           System.Exit
+import           System.IO
 import           Text.ParserCombinators.ReadP
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix

+import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Version                  as V
@@ -58,7 +66,7 @@ addError = do
  liftIO $ modifyIORef ref (+ 1)


-validate :: (Monad m, MonadReader env m, HasLog env, MonadThrow m, MonadIO m, MonadUnliftIO m)
+validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
         => GHCupDownloads
         -> M.Map GlobalTool DownloadInfo
         -> m ExitCode
@@ -85,23 +93,24 @@ validate dls _ = do
    if e > 0
      then pure $ ExitFailure e
      else do
-        lift $ logInfo "All good"
+        lift $ $(logInfo) [i|All good|]
        pure ExitSuccess
 where
  checkHasRequiredPlatforms t v tags arch pspecs = do
    let v' = prettyVer v
        arch' = prettyShow arch
    when (notElem (Linux UnknownLinux) pspecs) $ do
-      lift $ logError $
-        "Linux UnknownLinux missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+      lift $ $(logError)
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
      addError
    when ((notElem Darwin pspecs) && arch == A_64) $ do
-      lift $ logError $ "Darwin missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
      addError
-    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ logWarn $
-      "FreeBSD missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
+      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
    when (notElem Windows pspecs && arch == A_64) $ do
-      lift $ logError $ "Windows missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
+      lift $ $(logError)
+        [i|Windows missing for for #{t} #{v'} #{arch'}|]
      addError

    -- alpine needs to be set explicitly, because
@@ -109,15 +118,15 @@ validate dls _ = do
    -- (although it could be static)
    when (notElem (Linux Alpine) pspecs) $
      case t of
-        GHCup | arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
+        GHCup | arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
        Cabal | v > [vver|2.4.1.0|]
-              , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
+              , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
        GHC | Latest `elem` tags || Recommended `elem` tags
-            , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch))
-        _ -> lift $ logWarn $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)
+            , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|])
+        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]

  checkUniqueTags tool = do
-    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
    let nonUnique =
          fmap fst
            .   filter (\(_, b) -> not b)
@@ -134,7 +143,7 @@ validate dls _ = do
    case join nonUnique of
      [] -> pure ()
      xs -> do
-        lift $ logError $ "Tags not unique for " <> T.pack (prettyShow tool) <> ": " <> T.pack (prettyShow xs)
+        lift $ $(logError) [i|Tags not unique for #{tool}: #{xs}|]
        addError
   where
    isUniqueTag Latest         = True
@@ -150,24 +159,24 @@ validate dls _ = do
      case [ x | (x,"") <- readP_to_S V.parseVersion (T.unpack . prettyVer $ v) ] of
        [_] -> pure ()
        _   -> do
-          lift $ logError $ "GHC version " <> prettyVer v <> " is not valid"
+          lift $ $(logError) [i|GHC version #{v} is not valid |]
          addError

  -- a tool must have at least one of each mandatory tags
  checkMandatoryTags tool = do
-    let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
    forM_ [Latest, Recommended] $ \t -> case elem t allTags of
      False -> do
-        lift $ logError $ "Tag " <> T.pack (prettyShow t) <> " missing from " <> T.pack (prettyShow tool)
+        lift $ $(logError) [i|Tag #{t} missing from #{tool}|]
        addError
      True -> pure ()

  -- all GHC versions must have a base tag
  checkGHCHasBaseVersion = do
    let allTags = M.toList $ availableToolVersions dls GHC
-    forM allTags $ \(ver, _viTags -> tags) -> case any isBase tags of
+    forM allTags $ \(ver, tags) -> case any isBase tags of
      False -> do
-        lift $ logError $ "Base tag missing from GHC ver " <> prettyVer ver
+        lift $ $(logError) [i|Base tag missing from GHC ver #{ver}|]
        addError
      True -> pure ()

@@ -180,10 +189,7 @@ data TarballFilter = TarballFilter
  }

 validateTarballs :: ( Monad m
-                    , MonadReader env m
-                    , HasLog env
-                    , HasDirs env
-                    , HasSettings env
+                    , MonadLogger m
                    , MonadThrow m
                    , MonadIO m
                    , MonadUnliftIO m
@@ -198,83 +204,94 @@ validateTarballs :: ( Monad m
 validateTarballs (TarballFilter etool versionRegex) dls gt = do
  ref <- liftIO $ newIORef 0

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

-  -- exit
-  e <- liftIO $ readIORef ref
-  if e > 0
-    then pure $ ExitFailure e
-    else do
-      logInfo "All good"
-      pure ExitSuccess
+    -- exit
+    e <- liftIO $ readIORef ref
+    if e > 0
+      then pure $ ExitFailure e
+      else do
+        lift $ $(logInfo) [i|All good|]
+        pure ExitSuccess

 where
-  downloadAll :: ( MonadUnliftIO m
-                 , MonadIO m
-                 , MonadReader env m
-                 , HasLog env
-                 , HasDirs env
-                 , HasSettings env
-                 , MonadCatch m
-                 , MonadMask m
-                 , MonadThrow m
-                 )
-              => IORef Int
-              -> DownloadInfo
-              -> m ()
-  downloadAll ref dli = do
-    r <- runResourceT
+  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                     , colorOutter  = B.hPut stderr
+                                     , rawOutter    = \_ -> pure ()
+                                     }
+  downloadAll dli = do
+    dirs <- liftIO getDirs
+
+    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 appstate
+      . runResourceT
      . runE @'[DigestError
-               , GPGError
               , DownloadFailed
               , UnknownArchive
+#if defined(TAR)
+               , Tar.FormatError
+#else
               , ArchiveResult
+#endif
               ]
      $ do
        case etool of
          Right (Just GHCup) -> do
            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- liftE $ download (settings appstate) dli tmpUnpack Nothing
            pure Nothing
          Right _ -> do
-            p <- liftE $ downloadCached dli Nothing
+            p <- liftE $ downloadCached (settings appstate) dirs dli Nothing
            fmap (Just . head . splitDirectories . head)
              . liftE
              . getArchiveFiles
              $ p
          Left ShimGen -> do
            tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- liftE $ download (settings appstate) dli tmpUnpack Nothing
            pure Nothing
    case r of
      VRight (Just basePath) -> do
        case _dlSubdir dli of
          Just (RealDir prel) -> do
-            logInfo
-              $ " verifying subdir: " <> T.pack prel
+            lift $ $(logInfo)
+              [i|verifying subdir: #{prel}|]
            when (basePath /= prel) $ do
-              logError $
-                "Subdir doesn't match: expected " <> T.pack prel <> ", got " <> T.pack basePath
-              (flip runReaderT ref addError)
+              lift $ $(logError)
+                [i|Subdir doesn't match: expected "#{prel}", got "#{basePath}"|]
+              addError
          Just (RegexDir regexString) -> do
-            logInfo $
-              "verifying subdir (regex): " <> T.pack regexString
+            lift $ $(logInfo)
+              [i|verifying subdir (regex): #{regexString}|]
            let regex = makeRegexOpts
                  compIgnoreCase
                  execBlank
                  regexString
            when (not (match regex basePath)) $ do
-              logError $
-                "Subdir doesn't match: expected regex " <> T.pack regexString <> ", got " <> T.pack basePath
-              (flip runReaderT ref addError)
+              lift $ $(logError)
+                [i|Subdir doesn't match: expected regex "#{regexString}", got "#{basePath}"|]
+              addError
          Nothing -> pure ()
      VRight Nothing -> pure ()
      VLeft  e -> do
-        logError $
-          "Could not download (or verify hash) of " <> T.pack (show dli) <> ", Error was: " <> T.pack (prettyShow e)
-        (flip runReaderT ref addError)
+        lift $ $(logError)
+          [i|Could not download (or verify hash) of #{dli}, Error was: #{prettyShow e}|]
+        addError
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -13,11 +13,11 @@ module BrickMain where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Types         hiding ( LeanAppState(..) )
+import           GHCup.Types
 import           GHCup.Utils
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude ( decUTF8Safe )
 import           GHCup.Utils.File
+import           GHCup.Utils.Logger

 import           Brick
 import           Brick.Widgets.Border
@@ -27,8 +27,11 @@ import           Brick.Widgets.List             ( listSelectedFocusedAttr
                                                , listSelectedAttr
                                                , listAttr
                                                )
+#if !defined(TAR)
 import           Codec.Archive
+#endif
 import           Control.Exception.Safe
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.Resource
@@ -37,24 +40,28 @@ import           Data.Functor
 import           Data.List
 import           Data.Maybe
 import           Data.IORef
+import           Data.String.Interpolate
 import           Data.Vector                    ( Vector
                                                , (!?)
                                                )
 import           Data.Versions           hiding ( str )
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( appendFile )
+import           System.Environment
 import           System.Exit
 import           System.IO.Unsafe
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

+import qualified GHCup.Types                   as GT
+
 import qualified Data.Text                     as T
 import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V


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


 data BrickData = BrickData
@@ -164,7 +171,7 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
          | elem Latest lTag && not lInstalled =
              withAttr "hooray"
          | otherwise = id
-        active = if b then putCursor "GHCup" (Location (0,0)) . forceAttr "active" else id
+        active = if b then forceAttr "active" else id
    in  hooray $ active $ dim
          (   marks
          <+> padLeft (Pad 2)
@@ -252,7 +259,7 @@ app attrs dimAttrs =
  , appHandleEvent  = eventHandler
  , appStartEvent   = return
  , appAttrMap      = const attrs
-  , appChooseCursor = showFirstCursor
+  , appChooseCursor = neverShowCursor
  }

 defaultAttributes :: Bool -> AttrMap
@@ -415,11 +422,17 @@ install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, Monad
 install' _ (_, ListResult {..}) = do
  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask

+  l        <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+
  let run =
-        runResourceT
+        runLogger
+          . runResourceT
          . runE
            @'[ AlreadyInstalled
+#if !defined(TAR)
              , ArchiveResult
+#endif
              , UnknownArchive
              , FileDoesNotExistError
              , CopyError
@@ -428,49 +441,49 @@ install' _ (_, ListResult {..}) = do
              , BuildFailed
              , TagNotFound
              , DigestError
-              , GPGError
              , DownloadFailed
-              , DirNotEmpty
              , NoUpdate
              , TarDirDoesNotExist
-              , FileAlreadyExistsError
              ]

  run (do
      case lTool of
        GHC   -> do
          let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin lVer Nothing False $> vi
+          liftE $ installGHCBin lVer $> vi
        Cabal -> do
          let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin lVer Nothing False $> vi
+          liftE $ installCabalBin lVer $> vi
        GHCup -> do
          let vi = snd <$> getLatest dls GHCup
          liftE $ upgradeGHCup Nothing False $> vi
        HLS   -> do
          let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin lVer Nothing False $> vi
+          liftE $ installHLSBin lVer $> vi
        Stack -> do
          let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin lVer Nothing False $> vi
+          liftE $ installStackBin lVer $> vi
    )
    >>= \case
          VRight vi                         -> do
            forM_ (_viPostInstall =<< vi) $ \msg ->
-              logInfo msg
+              myLoggerT l $ $(logInfo) msg
            pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
          VLeft (V NoUpdate) -> pure $ Right ()
-          VLeft e -> pure $ Left $ prettyShow e <> "\n"
-            <> "Also check the logs in ~/.ghcup/logs"
+          VLeft e -> pure $ Left [i|#{prettyShow e}
+Also check the logs in ~/.ghcup/logs|]


 set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 set' _ (_, ListResult {..}) = do
  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l

  let run =
-        flip runReaderT settings
+        runLogger
+          . flip runReaderT settings
          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]

  run (do
@@ -493,7 +506,9 @@ del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnlif
 del' _ (_, ListResult {..}) = do
  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask

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

  run (do
      let vi = getVersionInfo lVer lTool dls
@@ -507,7 +522,7 @@ del' _ (_, ListResult {..}) = do
    >>= \case
          VRight vi -> do
            forM_ (join $ fmap _viPostRemove vi) $ \msg ->
-              logInfo msg
+              runLogger $ $(logInfo) msg
            pure $ Right ()
          VLeft  e -> pure $ Left (prettyShow e)

@@ -519,8 +534,8 @@ changelog' :: (MonadReader AppState m, MonadIO m)
 changelog' _ (_, ListResult {..}) = do
  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
  case getChangeLog dls lTool (Left lVer) of
-    Nothing -> pure $ Left $
-      "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
+    Nothing -> pure $ Left
+      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
    Just uri -> do
      let cmd = case _rPlatform pfreq of
            Darwin  -> "open"
@@ -535,50 +550,58 @@ changelog' _ (_, ListResult {..}) = do
 settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
-  dirs <- getAllDirs
-  let loggerConfig = LoggerConfig { lcPrintDebug  = False
-                                  , consoleOutter = \_ -> pure ()
-                                  , fileOutter    = \_ -> pure ()
-                                  , fancyColors   = True
-                                  }
+  dirs <- getDirs
  newIORef $ AppState (Settings { cache      = True
                                , noVerify   = False
                                , keepDirs   = Never
                                , downloader = Curl
                                , verbose    = False
                                , urlSource  = GHCupURL
-                                , noNetwork  = False
-                                , gpgSetting = GPGNone
-                                , noColor    = False
                                , ..
                                })
                      dirs
                      defaultKeyBindings
                      (GHCupInfo mempty mempty mempty)
                      (PlatformRequest A_64 Darwin Nothing)
-                      loggerConfig



+logger' :: IORef LoggerConfig
+{-# NOINLINE logger' #-}
+logger' = unsafePerformIO
+  (newIORef $ LoggerConfig { lcPrintDebug = False
+                           , colorOutter  = \_ -> pure ()
+                           , rawOutter    = \_ -> pure ()
+                           }
+  )
+
+
 brickMain :: AppState
+          -> LoggerConfig
+          -> GHCupInfo
          -> IO ()
-brickMain s = do
+brickMain s l gi = do
  writeIORef settings' s
+  -- logger interpreter
+  writeIORef logger'   l
+  let runLogger = myLoggerT l

-  eAppData <- getAppData (Just $ ghcupInfo s)
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+
+  eAppData <- getAppData (Just gi)
  case eAppData of
    Right ad ->
      defaultMain
-          (app (defaultAttributes (noColor $ settings s)) (dimAttributes (noColor $ settings s)))
+          (app (defaultAttributes no_color) (dimAttributes no_color))
          (BrickState ad
                    defaultAppSettings
                    (constructList ad defaultAppSettings Nothing)
-                    (keyBindings (s :: AppState))
+                    (keyBindings s)

          )
        $> ()
    Left e -> do
-      flip runReaderT s $ logError $ "Error building app state: " <> T.pack (show e)
+      runLogger ($(logError) [i|Error building app state: #{show e}|])
      exitWith $ ExitFailure 2


@@ -589,12 +612,15 @@ defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = Fal
 getGHCupInfo :: IO (Either String GHCupInfo)
 getGHCupInfo = do
  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l

  r <-
-    flip runReaderT settings
-    . runE @'[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
+    runLogger
+    . flip runReaderT settings
+    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
    $ liftE
-    $ getDownloadsF
+    $ getDownloadsF (GT.settings settings) (GT.dirs settings)

  case r of
    VRight a -> pure $ Right a
@@ -604,11 +630,14 @@ getGHCupInfo = do
 getAppData :: Maybe GHCupInfo
           -> IO (Either String BrickData)
 getAppData mgi = runExceptT $ do
+  l        <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+
  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
  settings <- liftIO $ readIORef settings'

-  flip runReaderT settings $ do
+  runLogger . flip runReaderT settings $ do
    lV <- listVersions Nothing Nothing
    pure $ BrickData (reverse lV)

--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
--- a/484
+++ b/484
@@ -0,0 +1,484 @@
+#!/bin/sh
+
+# Main settings:
+#   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
+#   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
+#   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
+#   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
+#   * BOOTSTRAP_HASKELL_GHC_VERSION
+#   * BOOTSTRAP_HASKELL_CABAL_VERSION
+
+# License: LGPL-3.0
+
+
+# safety subshell to avoid executing anything in case this script is not downloaded properly
+(
+
+plat="$(uname -s)"
+arch=$(uname -m)
+ghver="0.1.15.2"
+base_url="https://downloads.haskell.org/~ghcup"
+
+case "${plat}" in
+        MSYS*|MINGW*)
+			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
+			GHCUP_DIR=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup")
+			GHCUP_BIN=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup/bin")
+			: "${GHCUP_MSYS2:=${GHCUP_DIR}/msys64}"
+			;;
+		*)
+			: "${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
+			;;
+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!"
+}
+
+eghcup() {
+	edo _eghcup "$@"
+}
+
+_eghcup() {
+	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
+		args="-s ${BOOTSTRAP_HASKELL_YAML}"
+	fi 
+    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
+        "${GHCUP_BIN}/ghcup" ${args} "$@"
+    else
+        "${GHCUP_BIN}/ghcup" ${args} --verbose "$@"
+    fi
+}
+
+_done() {
+	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() {
+
+    case "${plat}" in
+        "linux"|"Linux")
+			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}
+					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+						_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}
+					;;
+				armv7*)
+					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
+					;;
+				aarch64|arm64|armv8l)
+					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			;;
+        "FreeBSD"|"freebsd")
+			case "${arch}" in
+				x86_64|amd64)
+					;;
+				i*86)
+					die "i386 currently not supported!"
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
+            ;;
+        "Darwin"|"darwin")
+			case "${arch}" in
+				x86_64|amd64)
+					_url=${base_url}/${ghver}/x86_64-apple-darwin-ghcup-${ghver}
+					;;
+				aarch64|arm64|armv8l)
+					_url=${base_url}/${ghver}/aarch64-apple-darwin-ghcup-${ghver}
+					;;
+				i*86)
+					die "i386 currently not supported!"
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			;;
+        MSYS*|MINGW*)
+			case "${arch}" in
+				x86_64|amd64)
+					_url=${base_url}/${ghver}/x86_64-mingw64-ghcup-${ghver}.exe
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			;;
+        *) die "Unknown platform: ${plat}"
+			;;
+    esac
+    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"
+		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
+		EOF
+	# shellcheck disable=SC1090
+    edo . "${GHCUP_DIR}"/env
+    eghcup upgrade
+}
+
+adjust_bashrc() {
+	case $SHELL in
+		*/zsh) # login shell is zsh
+			GHCUP_PROFILE_FILE="$HOME/.zshrc"
+			MY_SHELL="zsh" ;;
+		*/bash) # login shell is bash
+			GHCUP_PROFILE_FILE="$HOME/.bashrc"
+			MY_SHELL="bash" ;;
+		*/sh) # login shell is sh, but might be a symlink to bash or zsh
+			if [ -n "${BASH}" ] ; then
+				GHCUP_PROFILE_FILE="$HOME/.bashrc"
+				MY_SHELL="bash"
+			elif [ -n "${ZSH_VERSION}" ] ; then
+				GHCUP_PROFILE_FILE="$HOME/.zshrc"
+				MY_SHELL="zsh"
+			else
+				return
+			fi
+			;;
+		*/fish) # login shell is fish
+			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
+			MY_SHELL="fish" ;;
+		*) return ;;
+	esac
+
+
+	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
+		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+			read -r next_answer </dev/tty
+		else
+			next_answer="yes"
+		fi
+
+		case $next_answer in
+			[Nn]*)
+				return ;;
+			[Yy]* | "")
+				case $MY_SHELL in
+					"") break ;;
+					fish)
+							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
+							sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
+							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						break ;;
+					bash)
+						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
+						echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						case "${plat}" in
+							"Darwin"|"darwin")
+								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
+									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
+								fi
+								;;
+						esac
+						break ;;
+
+					zsh)
+						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
+						echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						break ;;
+				esac
+				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."
+				return
+				;;
+			*)
+				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
+}
+
+
+echo
+echo "Welcome to Haskell!"
+echo
+echo "This script will download and install the following binaries:"
+echo "  * ghcup - The Haskell toolchain installer"
+echo "  * ghc   - The Glasgow Haskell Compiler"
+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:"
+	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."
+fi
+echo
+
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+    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
+    read -r answer </dev/tty
+fi
+
+edo mkdir -p "${GHCUP_BIN}"
+
+if command -V "ghcup" >/dev/null 2>&1 ; then
+    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
+        _eghcup upgrade || download_ghcup
+    fi
+else
+	download_ghcup
+fi
+
+echo
+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
+    warn "Press ENTER to proceed or ctrl-c to abort."
+    warn "Installation may take a while."
+    echo
+
+    # Wait for user input to continue.
+    # shellcheck disable=SC2034
+    read -r answer </dev/tty
+fi
+
+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_MSYS2"/usr/bin), $(cygpath -w "$GHCUP_MSYS2"/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_MSYS2"/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)."
+							echo "And set the environment variable GHCUP_MSYS2 to the root path of your msys2 installation."
+							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
+
+
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+	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
+
+		case $hls_answer in
+			[Yy]*)
+				_eghcup --cache install hls || warn "HLS installation failed, continuing anyway"
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				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 || warn "Stack installation failed, continuing anyway"
+				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
+fi
+
+# short-circuit script based on platform
+case "${plat}" in
+        MSYS*|MINGW*)
+			# For windows we always adjust bashrc, since it's inside msys2
+			adjust_bashrc
+			;;
+		*)
+        	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+				echo "In order to run ghc and cabal, you need to adjust your PATH variable."
+				echo "You may want to source '$GHCUP_DIR/env' in your shell"
+				echo "configuration to do so (e.g. ~/.bashrc)."
+
+				adjust_bashrc
+			fi
+			;;
+esac
+
+_done
+
+)
+
+# vim: tabstop=4 shiftwidth=4 expandtab
+
--- a/scripts/bootstrap/bootstrap-haskell.ps1
+++ b/scripts/bootstrap/bootstrap-haskell.ps1
@@ -15,26 +15,18 @@
 param (
    # Run an interactive installation
    [switch]$Interactive,
-    # Do minimal installation of ghcup and msys2 only
-    [switch]$Minimal,
-    # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
-    [switch]$InBash,
-    # Overwrite (or rather backup) a previous install
-    [switch]$Overwrite,
-    # Skip adjusting cabal.config with mingw paths
-    [switch]$NoAdjustCabalConfig,
-    # Whether to install stack as well
-    [switch]$InstallStack,
-    # Whether to install hls as well
-    [switch]$InstallHLS,
-    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
+    # Specify the install root (default: 'C:\')
    [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
+    [string]$CabalDir,
+    # Overwrite (or rather backup) a previous install
+    [switch]$Overwrite,
+    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
+    [string]$BootstrapUrl,
+    # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
+    [switch]$InBash
 )

 $Silent = !$Interactive
@@ -160,29 +152,9 @@ $ErrorActionPreference = 'Stop'

 $GhcupBasePrefixEnv = [System.Environment]::GetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', 'user')

-if (Get-Command -Name 'chocolatey.exe' -ErrorAction SilentlyContinue) {
-  if (!($Silent)) {
-    Print-Msg -color Magenta -msg (@'
-Chocolatey was detected on your system. It is capable of installing the Haskell toolchain as well.
-If you want to rather use that instead of ghcup, abort the installation and run the following at an
-elevated command prompt:
-    choco install haskell-dev
-    refreshenv
-
-'@)
-    $decision = $Host.UI.PromptForChoice(''
-    , 'Continue with GHCup installation?'
-    , [System.Management.Automation.Host.ChoiceDescription[]] @('&Continue'
-        '&Abort'), 0)
-    if ($decision -eq 1) {
-      Exit 0
-    }
-  }
-}
-
 if ($GhcupBasePrefixEnv) {
  $defaultGhcupBasePrefix = $GhcupBasePrefixEnv
-} elseif (!($InstallDir)) {
+} else {
  $partitions = Get-CimInstance win32_logicaldisk
  $defaultGhcupBasePrefix = $null
  foreach ($p in $partitions){
@@ -206,15 +178,14 @@ if ($GhcupBasePrefixEnv) {
  }
 }

-# ask for base install prefix
 if ($Silent -and !($InstallDir)) {
  $GhcupBasePrefix = $defaultGhcupBasePrefix
 } elseif ($InstallDir) {
  if (!(Test-Path -LiteralPath ('{0}' -f $InstallDir) -IsValid)) {
-    Print-Msg -color Red -msg "Not a valid directory! (InstallDir)"
+    Print-Msg -color Red -msg "Not a valid directory!"
    Exit 1
  } elseif (!(Split-Path -IsAbsolute -Path "$InstallDir")) {
-    Print-Msg -color Red -msg "Non-absolute Path specified! (InstallDir)"
+    Print-Msg -color Red -msg "Non-absolute Path specified!"
    Exit 1
  } else {
    $GhcupBasePrefix = $InstallDir
@@ -245,20 +216,7 @@ $null = [Environment]::SetEnvironmentVariable("GHCUP_INSTALL_BASE_PREFIX", $Ghcu


 $GhcupDir = ('{0}\ghcup' -f $GhcupBasePrefix)
-if ($ExistingMsys2Dir) {
-  if (!(Test-Path -LiteralPath ('{0}' -f $ExistingMsys2Dir) -IsValid)) {
-    Print-Msg -color Red -msg "Not a valid directory! (ExistingMsys2Dir)"
-    Exit 1
-  } elseif (!(Split-Path -IsAbsolute -Path "$ExistingMsys2Dir")) {
-    Print-Msg -color Red -msg "Non-absolute Path specified! (ExistingMsys2Dir)"
-    Exit 1
-  } else {
-	$MsysDir = $ExistingMsys2Dir
-  }
-} else {
-	$MsysDir = ('{0}\msys64' -f $GhcupDir)
-}
-
+$MsysDir = ('{0}\msys64' -f $GhcupDir)
 $Bash = ('{0}\usr\bin\bash' -f $MsysDir)
 if (!($BootstrapUrl)) {
  $BootstrapUrl = 'https://www.haskell.org/ghcup/sh/bootstrap-haskell'
@@ -267,7 +225,6 @@ $GhcupMsys2 = [System.Environment]::GetEnvironmentVariable('GHCUP_MSYS2', 'user'

 Print-Msg -msg 'Preparing for GHCup installation...'

-# ask what to do in case ghcup is already installed
 if (Test-Path -LiteralPath ('{0}' -f $GhcupDir)) {
  Print-Msg -msg ('GHCup already installed at ''{0}''...' -f $GhcupDir)
  if ($Overwrite) {
@@ -297,73 +254,8 @@ if (Test-Path -LiteralPath ('{0}' -f $GhcupDir)) {
 $null = New-Item -Path ('{0}' -f $GhcupDir) -ItemType 'directory' -ErrorAction SilentlyContinue
 $null = New-Item -Path ('{0}' -f $GhcupDir) -Name 'bin' -ItemType 'directory' -ErrorAction SilentlyContinue

-# ask for cabal dir destination
-if ($CabalDir) {
-  $CabDirEnv = $CabalDir
-  if (!($CabDirEnv)) {
-    Print-Msg -color Red -msg "No directory specified!"
-    Exit 1        
-  } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-    Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    Exit 1
-  }
-} elseif (!($Silent)) {
-  while ($true) {
-
-    $defaultCabalDir = ('{0}\cabal' -f $GhcupBasePrefix)
-    Print-Msg -color Magenta -msg ('Specify Cabal directory (this is where haskell packages end up){1}Press enter to accept the default [{0}]:' -f $defaultCabalDir, "`n")
-    $CabalDirPrompt = Read-Host
-    $CabDirEnv = ($defaultCabalDir,$CabalDirPrompt)[[bool]$CabalDirPrompt]
-
-    if (!($CabDirEnv)) {
-      Print-Msg -color Red -msg "No directory specified!"         
-    } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    } else {
-      Break
-    }
-  }
-} else {
-  $CabDirEnv = ('{0}\cabal' -f $GhcupBasePrefix)
-}
-
-# ask whether to install HLS
-if (!($InstallHLS)) {
-  if (!($Silent)) {
-    $HLSdecision = $Host.UI.PromptForChoice('Install HLS'
-      , 'Do you want to install the haskell-language-server (HLS) for development purposes as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($HLSdecision -eq 0) {
-      $InstallHLS = $true
-    } elseif ($HLSdecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-# ask whether to install stack
-if (!($InstallStack)) {
-  if (!($Silent)) {
-    $StackDecision = $Host.UI.PromptForChoice('Install stack'
-      , 'Do you want to install stack as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($StackDecision -eq 0) {
-      $InstallStack = $true
-    } elseif ($StackDecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-
-# mingw foo
 Print-Msg -msg 'First checking for Msys2...'
+
 if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
  if ($Silent) {
    $msys2Decision = 0
@@ -375,10 +267,7 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
  }

  if ($msys2Decision -eq 0) {
-    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0}' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
+    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...'
@@ -406,20 +295,19 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
    Exec "$Bash" '-lc' 'pacman --noconfirm -Syuu'

    Print-Msg -msg 'Installing Dependencies...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -S --needed curl autoconf mingw-w64-x86_64-pkgconf'
+    Exec "$Bash" '-lc' 'pacman --noconfirm -S --needed curl mingw-w64-x86_64-pkgconf'

    Print-Msg -msg 'Updating SSL root certificate authorities...'
    Exec "$Bash" '-lc' 'pacman --noconfirm -S ca-certificates'

    Print-Msg -msg 'Setting default home directory...'
    Exec "$Bash" '-lc' "sed -i -e 's/db_home:.*$/db_home: windows/' /etc/nsswitch.conf"
-
  } elseif ($msys2Decision -eq 1) {
    Print-Msg -color Yellow -msg 'Skipping MSys2 installation.'
    while ($true) {
      if ($GhcupMsys2) {
        $defaultMsys2Dir = $GhcupMsys2
-        Print-Msg -color Magenta -msg ('Input existing MSys2 toolchain directory.{1}Press enter to accept the default [{0}]:' -f $defaultMsys2Dir, "`n")
+        Print-Msg -color Magenta -msg ('Input existing MSys2 toolchain directory. Press enter to accept the default [{0}]:' -f $defaultMsys2Dir)
        $MsysDirPrompt = Read-Host
        $MsysDir = ($defaultMsys2Dir,$MsysDirPrompt)[[bool]$MsysDirPrompt]
      } else {
@@ -442,85 +330,46 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
  }
 } else {
    Print-Msg -msg ('...Msys2 found in {0} ...skipping Msys2 installation.' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
 }

 Print-Msg -msg 'Creating shortcuts...'
-$uninstallShortCut = @'
-$decision = $Host.UI.PromptForChoice('Uninstall Haskell'
-, 'Do you want to uninstall all of the haskell toolchain, including GHC, Cabal, Stack and GHCup itself?'
-, [System.Management.Automation.Host.ChoiceDescription[]] @('&Uninstall'
-    '&Abort'), 0)
-
-if ($decision -eq 1) {
-  Exit 0
-}
-
-Write-Host 'Removing ghcup toolchain' -ForegroundColor Green
-ghcup nuke
-
-Write-Host 'Unsetting GHCUP_INSTALL_BASE_PREFIX' -ForegroundColor Green
-[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)
-
-$ghcupMsys2 = [System.Environment]::GetEnvironmentVariable('GHCUP_MSYS2', 'user')
-$GhcupBasePrefixEnv = [System.Environment]::GetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', 'user')
-
-if ($ghcupMsys2) {
-  $msys2Dir = [IO.Path]::GetFullPath($ghcupMsys2)
-  $baseDir = [IO.Path]::GetFullPath('{0}\ghcup' -f $GhcupBasePrefixEnv)
-
-  if ($msys2Dir.StartsWith($baseDir)) {
-    Write-Host 'Unsetting GHCUP_MSYS2' -ForegroundColor Green
-    [Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)
-  } else {
-    Write-Host ('GHCUP_MSYS2 env variable is set to a non-standard location {0}. Environment variable not unset. Uninstall manually.' -f $msys2Dir) -ForegroundColor Magenta
-  }
-} else {
-  Write-Host 'Unsetting GHCUP_MSYS2' -ForegroundColor Green
-  [Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)
-}
-
-Write-Host 'Removing ghcup from PATH env var' -ForegroundColor Green
-$path = [System.Environment]::GetEnvironmentVariable(
-    'PATH',
-    'user'
-)
-$path = ($path.Split(';') | Where-Object { $_ -ne ('{0}\bin' -f $baseDir) }) -join ';'
-[System.Environment]::SetEnvironmentVariable(
-    'PATH',
-    $path,
-    'user'
-)
-
-Write-Host 'Removing desktop files' -ForegroundColor Green
-$DesktopDir = [Environment]::GetFolderPath("Desktop")
-Remove-Item -LiteralPath ('{0}\Install GHC dev dependencies.lnk' -f $DesktopDir) -Force
-Remove-Item -LiteralPath ('{0}\Mingw haskell shell.lnk' -f $DesktopDir) -Force
-Remove-Item -LiteralPath ('{0}\Mingw package management docs.url' -f $DesktopDir) -Force
-
-Write-Host ('CABAL_DIR env variable is still set to {0} and will be used by cabal regardless of ghcup. You may want to uninstall this manually.' -f [System.Environment]::GetEnvironmentVariable('CABAL_DIR', 'user')) -ForegroundColor Magenta
-Write-Host 'You may remove this script now.' -ForegroundColor Magenta
-
-if ($Host.Name -eq "ConsoleHost")
-{
-    Write-Host "Press any key to continue..."
-    $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyUp") > $null
-}
-'@
-
 $DesktopDir = [Environment]::GetFolderPath("Desktop")
 $GhcInstArgs = '-mingw64 -mintty -c "pacman --noconfirm -S --needed base-devel gettext autoconf make libtool automake python p7zip patch unzip"'
 Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe $GhcInstArgs -DestinationPath ('{0}\Install GHC dev dependencies.lnk' -f $DesktopDir)
 Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe '-mingw64' -DestinationPath ('{0}\Mingw haskell shell.lnk' -f $DesktopDir)
 Create-Shortcut -SourceExe 'https://www.msys2.org/docs/package-management' -ArgumentsToSourceExe '' -DestinationPath ('{0}\Mingw package management docs.url' -f $DesktopDir)
-$null = New-Item -Path $DesktopDir -Name "Uninstall Haskell.ps1" -ItemType "file" -Force -Value $uninstallShortCut

 Print-Msg -msg ('Adding {0}\bin to Users Path...' -f $GhcupDir)
 Add-EnvPath -Path ('{0}\bin' -f ([System.IO.Path]::GetFullPath("$GhcupDir"))) -Container 'User'

+if ($CabalDir) {
+  $CabDirEnv = $CabalDir
+  if (!($CabDirEnv)) {
+    Print-Msg -color Red -msg "No directory specified!"
+    Exit 1        
+  } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
+    Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
+    Exit 1
+  }
+} elseif (!($Silent)) {
+  while ($true) {

+    $defaultCabalDir = ('{0}\cabal' -f $GhcupBasePrefix)
+    Print-Msg -color Magenta -msg ('Specify Cabal directory (this is where haskell packages end up). Press enter to accept the default [{0}]:' -f $defaultCabalDir)
+    $CabalDirPrompt = Read-Host
+    $CabDirEnv = ($defaultCabalDir,$CabalDirPrompt)[[bool]$CabalDirPrompt]
+
+    if (!($CabDirEnv)) {
+      Print-Msg -color Red -msg "No directory specified!"         
+    } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
+      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
+    } else {
+      Break
+    }
+  }
+} else {
+  $CabDirEnv = ('{0}\cabal' -f $GhcupBasePrefix)
+}

 $CabalDirFull = [System.IO.Path]::GetFullPath("$CabDirEnv")
 Print-Msg -msg ('Setting CABAL_DIR to ''{0}''' -f $CabalDirFull)
@@ -530,29 +379,16 @@ Print-Msg -msg 'Starting GHCup installer...'

 $Msys2Shell = ('{0}\msys2_shell.cmd' -f $MsysDir)

-# The bootstrap script is always silent, since we ask relevant questions here
-$SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
-
-if ($InstallStack) {
-  $StackInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_STACK=1 ;'
-}
-
-if ($InstallHLS) {
-  $HLSInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_HLS=1 ;'
-}
-
-if (!($NoAdjustCabalConfig)) {
-  $AdjustCabalConfigExport = 'export BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG=1 ;'
-}
-
-if ($Minimal) {
-  $MinimalExport = 'export BOOTSTRAP_HASKELL_MINIMAL=1 ;'
+if ($Silent) {
+  $SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
+} else {
+  $SilentExport = ''
 }

 if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $MinimalExport)
+  Exec "$Bash" '-lc' ('{4} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull)
 } else {
-  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $MinimalExport)
+  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull)
 }


@@ -584,5 +420,3 @@ if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBa



-
-
--- a/cabal.ghc8104.project
+++ b/cabal.ghc8104.project
@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+optional-packages: ./3rdparty/*/*.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
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.ghc8104.project.freeze
+++ b/cabal.ghc8104.project.freeze
@@ -1,18 +1,16 @@
 active-repositories: hackage.haskell.org:merge
 constraints: any.Cabal ==3.2.1.0,
             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7.1,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
-             any.HsYAML ==0.2.1.0,
-             HsYAML -exe,
-             any.HsYAML-aeson ==0.2.0.0,
+             any.IfElse ==0.85,
             any.QuickCheck ==2.14.2,
             QuickCheck -old-random +templatehaskell,
-             any.StateVar ==1.2.2,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
-             aeson-pretty +lib-only,
+             aeson-pretty -lib-only,
             any.alex ==3.2.6,
             alex +small_base,
             any.ansi-terminal ==0.11,
@@ -20,113 +18,141 @@ constraints: any.Cabal ==3.2.1.0,
             any.ansi-wl-pprint ==0.6.9,
             ansi-wl-pprint -example,
             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
             any.assoc ==1.0.2,
             any.async ==2.2.3,
             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
-             any.base ==4.14.3.0,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.1.0,
             any.base-compat ==0.11.2,
             any.base-compat-batteries ==0.11.2,
             any.base-orphans ==0.8.4,
             any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
-             any.bifunctors ==5.5.11,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
             bifunctors +semigroups +tagged,
             any.binary ==0.8.8.0,
             any.blaze-builder ==0.4.2.1,
-             any.brick ==0.64,
-             brick -demos,
             any.bytestring ==0.10.12.0,
             any.bz2 ==1.0.1.0,
             bz2 -cross +with-bzlib,
-             any.c2hs ==0.28.8,
+             any.c2hs ==0.28.7,
             c2hs +base3 -regression,
-             any.cabal-plan ==0.7.2.0,
-             cabal-plan -_ -exe -license-report,
-             any.call-stack ==0.4.0,
+             any.call-stack ==0.3.0,
             any.case-insensitive ==1.2.1.0,
             any.casing ==0.1.4.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
             any.chs-cabal ==0.1.1.0,
             any.chs-deps ==0.1.0.0,
             chs-deps -cross,
             any.clock ==0.8.2,
             clock -llvm,
-             any.colour ==2.3.6,
+             any.cmdargs ==0.10.21,
+             cmdargs +quotation -testprog,
+             any.colour ==2.3.5,
             any.comonad ==5.0.8,
             comonad +containers +distributive +indexed-traversable,
             any.composition-prelude ==3.0.0.2,
             composition-prelude -development,
             any.concurrent-output ==1.10.12,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.5.1,
-             any.contravariant ==1.5.5,
+             any.conduit ==1.3.4.1,
+             any.conduit-extra ==1.3.5,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
             contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
-             any.data-fix ==0.3.2,
+             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.1,
             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
             any.directory ==1.3.6.0,
-             any.disk-free-space ==0.1.0.1,
             any.distributive ==0.6.2.1,
             distributive +semigroups +tagged,
             any.dlist ==1.0,
             dlist -werror,
+             any.easy-file ==0.2.2,
+             any.errors ==2.3.0,
             any.exceptions ==0.10.4,
+             any.fast-logger ==3.0.3,
             any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
             any.generic-arbitrary ==0.1.0,
-             any.ghc-boot-th ==8.10.7,
-             any.ghc-byteorder ==4.11.0.0.10,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.4,
             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
             any.happy ==1.20.0,
-             any.hashable ==1.3.3.0,
-             hashable +integer-gmp -random-initial-seed,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             any.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.7,
             any.haskus-utils-data ==1.4,
             any.haskus-utils-types ==1.5.1,
             any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
             any.hsc2hs ==0.68.7,
             hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
-             any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.3,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
             any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
-             any.http-io-streams ==0.1.6.0,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
             any.indexed-traversable ==0.1.1,
             any.indexed-traversable-instances ==0.1,
             any.integer-gmp ==1.0.3.0,
             any.integer-logarithms ==1.0.3.1,
             integer-logarithms -check-bounds +integer-gmp,
-             any.io-streams ==1.5.2.1,
-             io-streams +network -nointeractivetests +zlib,
-             any.language-c ==0.9.0.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
             libarchive -cross -low-memory -system-libarchive,
-             any.lzma-static ==5.2.5.4,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
             any.megaparsec ==9.0.1,
             megaparsec -dev,
             any.microlens ==0.4.12.0,
             any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
+             any.monad-logger ==0.3.36,
+             monad-logger +template_haskell,
+             any.monad-loops ==0.4.3,
+             monad-loops +base4,
+             any.mono-traversable ==1.0.15.1,
             any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
             network -devel,
-             any.network-uri ==2.6.4.1,
-             any.openssl-streams ==1.2.3.0,
+             any.old-locale ==1.0.0.7,
+             any.old-time ==1.1.0.3,
             any.optics ==0.4,
             any.optics-core ==0.4,
             optics-core -explicit-generic-labels,
             any.optics-extra ==0.4,
             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
             any.optparse-applicative ==0.16.1.0,
             optparse-applicative +process,
             any.os-release ==1.0.2,
@@ -135,79 +161,101 @@ constraints: any.Cabal ==3.2.1.0,
             any.parsec ==3.1.14.0,
             any.parser-combinators ==1.3.0,
             parser-combinators -dev,
-             any.polyparse ==1.13,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.2.0,
-             any.process ==1.6.13.2,
+             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
             any.profunctors ==5.6.2,
             any.quickcheck-arbitrary-adt ==0.3.1.0,
             any.quickcheck-io ==0.2.0,
             any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
+             any.recursion-schemes ==5.2.2,
             recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
-             any.regex-posix ==0.96.0.1,
+             any.regex-posix ==0.96.0.0,
             regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.3,
-             any.rts ==1.0.1,
+             any.resourcet ==1.2.4.2,
+             any.rts ==1.0,
             any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
-             any.scientific ==0.3.7.0,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
             scientific -bytestring-builder -integer-simple,
             any.semigroupoids ==5.3.5,
             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
             any.split ==0.2.3.4,
             any.splitmix ==0.1.0.3,
             splitmix -optimised-mixer,
-             any.stm ==2.5.0.1,
+             any.stm ==2.5.0.0,
+             any.stm-chans ==3.0.0.4,
+             any.streaming-commons ==0.2.2.1,
+             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
             any.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
             any.tagged ==0.8.6.1,
             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
             any.template-haskell ==2.16.0.0,
-             any.temporary ==1.3,
-             any.terminal-progress-bar ==0.4.1,
             any.terminal-size ==0.3.2.1,
             any.terminfo ==0.4.1.4,
             any.text ==1.2.4.1,
-             any.text-zipper ==0.11,
+             any.text-conversions ==0.3.1,
+             any.text-short ==0.1.3,
+             text-short -asserts,
             any.tf-random ==0.5,
             any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
+             any.th-compat ==0.1.1,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
             any.these ==1.1.1.1,
             these +assoc,
             any.time ==1.9.3,
-             any.time-compat ==1.9.6,
+             any.time-compat ==1.9.5,
             time-compat -old-locale,
             any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.6,
+             any.transformers-base ==0.4.5.2,
             transformers-base +orphaninstances,
-             any.transformers-compat ==0.7,
+             any.transformers-compat ==0.6.6,
             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
             any.unix ==2.7.2.2,
             any.unix-bytestring ==0.3.7.3,
             any.unix-compat ==0.5.3,
             unix-compat -old-time,
+             any.unix-time ==0.4.7,
             any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
+             any.unordered-containers ==0.2.13.0,
             unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
+             any.uri-bytestring ==0.3.3.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.0,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
             vector +boundschecks -internalchecks -unsafechecks -wall,
-             any.versions ==5.0.0,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
             any.vty ==5.33,
-             any.word-wrap ==0.4.1,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
             any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5
-index-state: hackage.haskell.org 2021-08-29T16:24:29Z
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
--- a/cabal.ghc8107.project
+++ b/cabal.ghc8107.project
@@ -1,34 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/libarchive
-    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-8.10.7
--- a/cabal.ghc884.project
+++ b/cabal.ghc884.project
@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.8.4
+
+optional-packages: ./3rdparty/*/*.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
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.ghc884.project.freeze
+++ b/cabal.ghc884.project.freeze
@@ -0,0 +1,262 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.0.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.6.0,
+             aeson -bytestring-builder -cffi -developer -fast,
+             any.aeson-pretty ==0.8.8,
+             aeson-pretty -lib-only,
+             any.alex ==3.2.6,
+             alex +small_base,
+             any.ansi-terminal ==0.11,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
+             any.assoc ==1.0.2,
+             any.async ==2.2.3,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.5,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.13.0.0,
+             any.base-compat ==0.11.2,
+             any.base-compat-batteries ==0.11.2,
+             any.base-orphans ==0.8.4,
+             any.base16-bytestring ==1.0.1.0,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.7.0,
+             any.blaze-builder ==0.4.2.1,
+             any.bytestring ==0.10.10.1,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.7,
+             c2hs +base3 -regression,
+             any.call-stack ==0.3.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
+             any.chs-cabal ==0.1.1.0,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.2,
+             clock -llvm,
+             any.cmdargs ==0.10.21,
+             cmdargs +quotation -testprog,
+             any.colour ==2.3.5,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.concurrent-output ==1.10.12,
+             any.conduit ==1.3.4.1,
+             any.conduit-extra ==1.3.5,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
+             contravariant +semigroups +statevar +tagged,
+             any.cryptohash-sha256 ==0.11.102.0,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
+             any.directory ==1.3.6.0,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.easy-file ==0.2.2,
+             any.errors ==2.3.0,
+             any.exceptions ==0.10.4,
+             exceptions +transformers-0-4,
+             any.fast-logger ==3.0.3,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.8.4,
+             any.ghc-prim ==0.5.3,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             any.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.7,
+             any.haskus-utils-data ==1.4,
+             any.haskus-utils-types ==1.5.1,
+             any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
+             any.hsc2hs ==0.68.7,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
+             any.indexed-traversable ==0.1.1,
+             any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.2.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
+             libarchive -cross -low-memory -system-libarchive,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
+             any.megaparsec ==9.0.1,
+             megaparsec -dev,
+             any.microlens ==0.4.12.0,
+             any.microlens-mtl ==0.2.0.1,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
+             any.monad-logger ==0.3.36,
+             monad-logger +template_haskell,
+             any.monad-loops ==0.4.3,
+             monad-loops +base4,
+             any.mono-traversable ==1.0.15.1,
+             any.mtl ==2.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
+             network -devel,
+             any.old-locale ==1.0.0.7,
+             any.old-time ==1.1.0.3,
+             any.optics ==0.4,
+             any.optics-core ==0.4,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4,
+             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
+             any.optparse-applicative ==0.16.1.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.2,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-posix ==0.96.0.0,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.4.2,
+             any.rts ==1.0,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
+             scientific -bytestring-builder -integer-simple,
+             any.semigroupoids ==5.3.5,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.3,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.0,
+             any.stm-chans ==3.0.0.4,
+             any.streaming-commons ==0.2.2.1,
+             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.15.0.0,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.4,
+             any.text ==1.2.4.0,
+             any.text-conversions ==0.3.1,
+             any.text-short ==0.1.3,
+             text-short -asserts,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.1,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.5,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.5.2,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.6.6,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.3,
+             any.unix-compat ==0.5.3,
+             unix-compat -old-time,
+             any.unix-time ==0.4.7,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.13.0,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.0,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
+             any.word8 ==0.1.3,
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
--- a/cabal.ghc901.project
+++ b/cabal.ghc901.project
@@ -1,34 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/libarchive
-    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-9.0.1
--- a/cabal.ghc901.project.freeze
+++ b/cabal.ghc901.project.freeze
@@ -1,213 +0,0 @@
-active-repositories: hackage.haskell.org:merge
-constraints: any.Cabal ==3.4.0.0,
-             any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7.1,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
-             any.HsYAML ==0.2.1.0,
-             HsYAML -exe,
-             any.HsYAML-aeson ==0.2.0.0,
-             any.QuickCheck ==2.14.2,
-             QuickCheck -old-random +templatehaskell,
-             any.StateVar ==1.2.2,
-             any.aeson ==1.5.6.0,
-             aeson -bytestring-builder -cffi -developer -fast,
-             any.aeson-pretty ==0.8.8,
-             aeson-pretty +lib-only,
-             any.alex ==3.2.6,
-             alex +small_base,
-             any.ansi-terminal ==0.11,
-             ansi-terminal -example,
-             any.ansi-wl-pprint ==0.6.9,
-             ansi-wl-pprint -example,
-             any.array ==0.5.4.0,
-             any.assoc ==1.0.2,
-             any.async ==2.2.3,
-             async -bench,
-             any.attoparsec ==0.13.2.5,
-             attoparsec -developer,
-             any.base ==4.15.0.0,
-             any.base-compat ==0.11.2,
-             any.base-compat-batteries ==0.11.2,
-             any.base-orphans ==0.8.4,
-             any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
-             any.bifunctors ==5.5.11,
-             bifunctors +semigroups +tagged,
-             any.binary ==0.8.8.0,
-             any.blaze-builder ==0.4.2.1,
-             any.brick ==0.64,
-             brick -demos,
-             any.bytestring ==0.10.12.1,
-             any.bz2 ==1.0.1.0,
-             bz2 -cross +with-bzlib,
-             any.c2hs ==0.28.8,
-             c2hs +base3 -regression,
-             any.cabal-plan ==0.7.2.0,
-             cabal-plan -_ -exe -license-report,
-             any.call-stack ==0.4.0,
-             any.case-insensitive ==1.2.1.0,
-             any.casing ==0.1.4.1,
-             any.chs-cabal ==0.1.1.0,
-             any.chs-deps ==0.1.0.0,
-             chs-deps -cross,
-             any.clock ==0.8.2,
-             clock -llvm,
-             any.colour ==2.3.6,
-             any.comonad ==5.0.8,
-             comonad +containers +distributive +indexed-traversable,
-             any.composition-prelude ==3.0.0.2,
-             composition-prelude -development,
-             any.concurrent-output ==1.10.12,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
-             any.contravariant ==1.5.5,
-             contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
-             any.cryptohash-sha256 ==0.11.102.0,
-             cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
-             any.data-fix ==0.3.2,
-             any.deepseq ==1.4.5.0,
-             any.directory ==1.3.6.1,
-             any.disk-free-space ==0.1.0.1,
-             any.distributive ==0.6.2.1,
-             distributive +semigroups +tagged,
-             any.dlist ==1.0,
-             dlist -werror,
-             any.exceptions ==0.10.4,
-             any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
-             any.generic-arbitrary ==0.1.0,
-             any.ghc-bignum ==1.0,
-             any.ghc-boot-th ==9.0.1,
-             any.ghc-byteorder ==4.11.0.0.10,
-             any.ghc-prim ==0.7.0,
-             any.happy ==1.20.0,
-             any.hashable ==1.3.3.0,
-             hashable +integer-gmp -random-initial-seed,
-             any.haskus-utils-data ==1.4,
-             any.haskus-utils-types ==1.5.1,
-             any.haskus-utils-variant ==3.1,
-             any.hsc2hs ==0.68.7,
-             hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
-             any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.3,
-             any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
-             any.http-io-streams ==0.1.6.0,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
-             any.indexed-traversable ==0.1.1,
-             any.indexed-traversable-instances ==0.1,
-             any.integer-logarithms ==1.0.3.1,
-             integer-logarithms -check-bounds +integer-gmp,
-             any.io-streams ==1.5.2.1,
-             io-streams +network -nointeractivetests +zlib,
-             any.language-c ==0.9.0.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
-             libarchive -cross -low-memory -system-libarchive,
-             any.lzma-static ==5.2.5.4,
-             any.megaparsec ==9.0.1,
-             megaparsec -dev,
-             any.microlens ==0.4.12.0,
-             any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
-             any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
-             network -devel,
-             any.network-uri ==2.6.4.1,
-             any.openssl-streams ==1.2.3.0,
-             any.optics ==0.4,
-             any.optics-core ==0.4,
-             optics-core -explicit-generic-labels,
-             any.optics-extra ==0.4,
-             any.optics-th ==0.4,
-             any.optparse-applicative ==0.16.1.0,
-             optparse-applicative +process,
-             any.os-release ==1.0.2,
-             os-release -devel,
-             any.parallel ==3.2.2.0,
-             any.parsec ==3.1.14.0,
-             any.parser-combinators ==1.3.0,
-             parser-combinators -dev,
-             any.polyparse ==1.13,
-             any.pretty ==1.1.3.6,
-             any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.2.0,
-             any.process ==1.6.11.0,
-             any.profunctors ==5.6.2,
-             any.quickcheck-arbitrary-adt ==0.3.1.0,
-             any.quickcheck-io ==0.2.0,
-             any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
-             recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
-             any.regex-posix ==0.96.0.1,
-             regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.3,
-             any.rts ==1.0,
-             any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
-             any.scientific ==0.3.7.0,
-             scientific -bytestring-builder -integer-simple,
-             any.semigroupoids ==5.3.5,
-             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
-             any.setenv ==0.1.1.3,
-             any.split ==0.2.3.4,
-             any.splitmix ==0.1.0.3,
-             splitmix -optimised-mixer,
-             any.stm ==2.5.0.0,
-             any.strict ==0.4.0.1,
-             strict +assoc,
-             any.strict-base ==0.4.0.0,
-             any.tagged ==0.8.6.1,
-             tagged +deepseq +transformers,
-             any.template-haskell ==2.17.0.0,
-             any.temporary ==1.3,
-             any.terminal-progress-bar ==0.4.1,
-             any.terminal-size ==0.3.2.1,
-             any.terminfo ==0.4.1.4,
-             any.text ==1.2.4.1,
-             any.text-zipper ==0.11,
-             any.tf-random ==0.5,
-             any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
-             any.th-lift ==0.8.2,
-             any.th-lift-instances ==0.1.18,
-             any.these ==1.1.1.1,
-             these +assoc,
-             any.time ==1.9.3,
-             any.time-compat ==1.9.6,
-             time-compat -old-locale,
-             any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.6,
-             transformers-base +orphaninstances,
-             any.transformers-compat ==0.7,
-             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
-             any.unix ==2.7.2.2,
-             any.unix-bytestring ==0.3.7.3,
-             any.unix-compat ==0.5.3,
-             unix-compat -old-time,
-             any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
-             unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
-             uri-bytestring -lib-werror,
-             any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
-             any.vector ==0.12.3.0,
-             vector +boundschecks -internalchecks -unsafechecks -wall,
-             any.versions ==5.0.0,
-             any.vty ==5.33,
-             any.word-wrap ==0.4.1,
-             any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5
-index-state: hackage.haskell.org 2021-08-29T16:24:29Z
--- a/cabal.project
+++ b/cabal.project
@@ -10,18 +10,17 @@ package ghcup

 source-repository-package
    type: git
-    location: https://github.com/hasufell/libarchive
-    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
+    location: https://github.com/Bodigrim/tar
+    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
+
+source-repository-package
+    type: git
+    location: https://github.com/bgamari/terminal-size
+    tag: 34ea816bd63f75f800eedac12c6908c6f3736036

 constraints: http-io-streams -brotli

 package libarchive
  flags: -system-libarchive

-package aeson-pretty
-  flags: +lib-only
-
-package cabal-plan
-  flags: -exe
-
 allow-newer: base, ghc-prim, template-haskell, language-c
--- a/data/config.yaml
+++ b/data/config.yaml
@@ -8,10 +8,6 @@ verbose: False
 keep-dirs: Errors  # Always | Never | Errors
 # Which downloader to use
 downloader: Curl   # Curl | Wget | Internal
-# whether to run in offline mode
-no-network: False
-# whether/how to do gpg verification
-gpg-setting: GPGNone # GPGStrict | GPGLax | GPGNone

 # TUI key bindings,
 # see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key
--- a/data/build_mk/cross
+++ b/data/build_mk/cross
@@ -1,9 +0,0 @@
-V=0
-BUILD_MAN = NO
-BUILD_SPHINX_HTML = NO
-BUILD_SPHINX_PDF = NO
-HADDOCK_DOCS = NO
-ifneq "$(BuildFlavour)" ""
-include mk/flavours/$(BuildFlavour).mk
-endif
-Stage1Only = YES
--- a/data/build_mk/default
+++ b/data/build_mk/default
@@ -1,8 +0,0 @@
-V=0
-BUILD_MAN = NO
-BUILD_SPHINX_HTML = NO
-BUILD_SPHINX_PDF = NO
-HADDOCK_DOCS = YES
-ifneq "$(BuildFlavour)" ""
-include mk/flavours/$(BuildFlavour).mk
-endif
--- a/data/metadata/ghcup-0.0.1.json
+++ b/data/metadata/ghcup-0.0.1.json
--- a/data/metadata/ghcup-0.0.2.json
+++ b/data/metadata/ghcup-0.0.2.json
--- a/data/metadata/ghcup-0.0.6.yaml
+++ b/data/metadata/ghcup-0.0.6.yaml
--- a/docs/RELEASING.md
+++ b/docs/RELEASING.md
@@ -1,21 +0,0 @@
-# RELEASING
-
-1. Update version in `ghcup.cabal` and `boostrap-haskell` (`ghver` variable at the top of the script)
-
-2. Update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `GHCupInfo` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version, read from `ghcup.cabal`.
-
-3. Add ChangeLog entry
-
-4. Add/fix downloads in `ghcup-<ver>.yaml` (under `data/metadata`), then verify with `ghcup-gen check -f ghcup-<ver>.yaml` and possibly (example only) `ghcup-gen check-tarballs -f ghcup-<ver>.yaml -u 'ghc-8.10.7'`. Generally, new GHC/cabal/stack/hls versions are only added to the latest yaml file. New GHCup versions are added to all (great care must be taken here to not break the parser... e.g. ARM platforms don't parse in all older formats).
-
-5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
-
-6. Download release artifacts and upload them `downloads.haskell.org/ghcup` along with checksum files (`sha256sum --tag * > SHA256SUMS && gpg --detach-sign -u <your-email> SHA256SUMS`)
-
-7. Add ghcup release artifacts to ALL yaml files (see point 4.)
-
-8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
-
-9. Update `bootstrap-haskell` and `bootstrap-haskell.ps1` to `webhost.haskell.org/ghcup/sh/`
-
-10. Update the ghcup symlinks at `downloads.haskell.org/ghcup`
--- a/data/metadata/ghcup-0.0.2.yaml
+++ b/data/metadata/ghcup-0.0.2.yaml
@@ -1384,7 +1384,7 @@ ghcupDownloads:
              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.16.2:
+    0.1.14:
      viTags:
      - Recommended
      - Latest
@@ -1394,22 +1394,22 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
-              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
-              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
-              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
-              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
          Linux_Alpine:
            unknown_versioning: *ghcup-32
--- a/data/metadata/ghcup-0.0.3.yaml
+++ b/data/metadata/ghcup-0.0.3.yaml
@@ -1451,7 +1451,7 @@ ghcupDownloads:
              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.16.2:
+    0.1.14:
      viTags:
      - Recommended
      - Latest
@@ -1461,23 +1461,23 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
-              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
-              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
-              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
-              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
          Linux_Alpine:
            unknown_versioning: *ghcup-32
  HLS:
--- a/data/metadata/ghcup-0.0.4.yaml
+++ b/data/metadata/ghcup-0.0.4.yaml
@@ -1868,7 +1868,7 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
              dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
  GHCup:
-    0.1.16.2:
+    0.1.15.2:
      viTags:
      - Recommended
      - Latest
@@ -1878,39 +1878,39 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
-              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-linux-ghcup-0.1.15.2
+              dlHash: 1eb1bb318a327754f42eaa2245bc81fe53be7c791160d28a186893ded3004ed7
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
-              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-apple-darwin-ghcup-0.1.15.2
+              dlHash: c2a6436a49f19f108493954d4a3efcb27503e343dd6288c2641784d32320b1ea
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
-              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-portbld-freebsd-ghcup-0.1.15.2
+              dlHash: 7e0c17dd78ebd9fd03e6ecea278c192bac31ca333721bde5b0ef99438b847a20
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
-              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/i386-linux-ghcup-0.1.15.2
+              dlHash: 3b1fe710cded0398e920ec9716089ba65226abf181741897f387e7c539a619c2
          Linux_Alpine:
            unknown_versioning: *ghcup-32
        A_ARM64:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-linux-ghcup-0.1.16.2
-              dlHash: 0bdbfc724e0ddabb266156eea83c2c4e19c6ed79dd06db0c29b7d69df8d9fa8c
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2
+              dlHash: d91b7a5416f292f2cf813824eb419f76ad9976d258cee3581123cb6eb01db9a7
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-apple-darwin-ghcup-0.1.16.2
-              dlHash: 8854e991a2ba1350abda59dab96ce50ae7729d1ce99399d67929ef31e90f1da5
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-apple-darwin-ghcup-0.1.15.2
+              dlHash: 20625ba5e7488f2a6155331750ecead3815ea16b2695c20521633c1412f012cc
        A_ARM:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/armv7-linux-ghcup-0.1.16.2
-              dlHash: 983ebb5b584bfa600704216a63f94b40d36a02573834e90ef1042c8472d9ad57
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2
+              dlHash: 03a4af5ed895ada1dd21f4cc3f64dc9078a5bf4268313021d004c04bea7f9c2e
  HLS:
    1.1.0:
      viTags:
--- a/data/metadata/ghcup-0.0.5.yaml
+++ b/data/metadata/ghcup-0.0.5.yaml
@@ -96,7 +96,6 @@ toolRequirements:
      Linux_Alpine:
        unknown_versioning:
          distroPKGs:
-          - binutils-gold
          - curl
          - gcc
          - g++
@@ -2025,7 +2024,7 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
              dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
  GHCup:
-    0.1.16.2:
+    0.1.15.2:
      viTags:
      - Recommended
      - Latest
@@ -2035,55 +2034,52 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
-              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-linux-ghcup-0.1.15.2
+              dlHash: 1eb1bb318a327754f42eaa2245bc81fe53be7c791160d28a186893ded3004ed7
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
-              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-apple-darwin-ghcup-0.1.15.2
+              dlHash: c2a6436a49f19f108493954d4a3efcb27503e343dd6288c2641784d32320b1ea
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
-              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-portbld-freebsd-ghcup-0.1.15.2
+              dlHash: 7e0c17dd78ebd9fd03e6ecea278c192bac31ca333721bde5b0ef99438b847a20
          Windows:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-mingw64-ghcup-0.1.16.2.exe
-              dlHash: ec78872a84213968c490675127b9aad2285980b747c68207801ae824b98c7948
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/x86_64-mingw64-ghcup-0.1.15.2.exe
+              dlHash: 4d832052754379531ac472aeef35666e433acfee79d4079826b8ede8ca5de520
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
-              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/i386-linux-ghcup-0.1.15.2
+              dlHash: 3b1fe710cded0398e920ec9716089ba65226abf181741897f387e7c539a619c2
          Linux_Alpine:
            unknown_versioning: *ghcup-32
        A_ARM64:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-linux-ghcup-0.1.16.2
-              dlHash: 0bdbfc724e0ddabb266156eea83c2c4e19c6ed79dd06db0c29b7d69df8d9fa8c
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r2
+              dlHash: d67702f7c9e3586e85ed7c1bd09b7544da55bd1d3b4a961a07018348f78cf76b
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-apple-darwin-ghcup-0.1.16.2
-              dlHash: 8854e991a2ba1350abda59dab96ce50ae7729d1ce99399d67929ef31e90f1da5
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-apple-darwin-ghcup-0.1.15.2
+              dlHash: 20625ba5e7488f2a6155331750ecead3815ea16b2695c20521633c1412f012cc
        A_ARM:
          Linux_UnknownLinux:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/armv7-linux-ghcup-0.1.16.2
-              dlHash: 983ebb5b584bfa600704216a63f94b40d36a02573834e90ef1042c8472d9ad57
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2
+              dlHash: 03a4af5ed895ada1dd21f4cc3f64dc9078a5bf4268313021d004c04bea7f9c2e
  HLS:
    1.1.0:
      viTags: []
      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#110
-      viPostInstall: &hls-post-install |
-        This is just the server part of your LSP configuration. Consult the README on how to
-        configure HLS, your project and your LSP client in your editor:
-          https://github.com/haskell/haskell-language-server/blob/master/README.md
+      viPostInstall: "This is just the server part of your LSP configuration. Consult the README on how to configure HLS, your project and your LSP client in your editor: https://github.com/haskell/haskell-language-server/blob/master/README.md"
      viArch:
        A_64:
          Linux_UnknownLinux:
-            unknown_versioning: &hls-110-64
+            unknown_versioning: &hls-64
              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.1.0/haskell-language-server-Linux-1.1.0.tar.gz
              dlHash: 0f0dadb0e9a08273658f565fd71c636801959b954be2737f38f2a1aac522208f
          Darwin:
@@ -2095,15 +2091,17 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/hls/1.1.0/haskell-language-server-Windows-1.1.0.tar.gz
              dlHash: a1d3f451e64a041aa527a25da29e4716a2de6ae347cef4ef9312fc7611e168cc
          Linux_Alpine:
-            unknown_versioning: *hls-110-64
+            unknown_versioning: *hls-64
    1.2.0:
-      viTags: []
+      viTags:
+        - Recommended
+        - Latest
      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#120
-      viPostInstall: *hls-post-install
+      viPostInstall: "This is just the server part of your LSP configuration. Consult the README on how to configure HLS, your project and your LSP client in your editor: https://github.com/haskell/haskell-language-server/blob/master/README.md"
      viArch:
        A_64:
          Linux_UnknownLinux:
-            unknown_versioning: &hls-120-64
+            unknown_versioning: &hls-64
              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.2.0/haskell-language-server-Linux-1.2.0.tar.gz
              dlHash: d29ee22f7bd706da2e2a1bd7640e25bb9736adeafb34eef47d29ea143b0fa927
          Darwin:
@@ -2115,46 +2113,15 @@ ghcupDownloads:
              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.2.0/haskell-language-server-Windows-1.2.0.tar.gz
              dlHash: 961c6ff12c9a9c7a4609f239c5ac70d7d16753cdb8c10348a6a51feeaa0b6aea
          Linux_Alpine:
-            unknown_versioning: *hls-120-64
-    1.3.0:
-      viTags:
-        - Recommended
-        - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#130
-      viPostInstall: *hls-post-install
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning: &hls-130-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.3.0/haskell-language-server-Linux-1.3.0.tar.gz
-              dlHash: d29ee22f7bd706da2e2a1bd7640e25bb9736adeafb34eef47d29ea143b0fa927
-          Darwin:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.3.0/haskell-language-server-macOS-1.3.0.tar.gz
-              dlHash: a310d8a3e9c5c4218210f750682c74a0f82ad0f59995adde0dbe775115b1e357
-          Windows:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.3.0/haskell-language-server-Windows-1.3.0.tar.gz
-              dlHash: 961c6ff12c9a9c7a4609f239c5ac70d7d16753cdb8c10348a6a51feeaa0b6aea
-          Linux_Alpine:
-            unknown_versioning: *hls-130-64
+            unknown_versioning: *hls-64
  Stack:
    2.5.1:
      viTags:
        - old
      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v251
      viPostInstall: &stack-post |
-        Stack manages GHC versions internally by default. In order to make it use ghcup installed
-        GHC versions you can run the following commands:
-          stack config set install-ghc false --global
-          stack config set system-ghc  true  --global
-        
-        On windows, you may find the following config options useful too:
-          skip-msys, extra-path, extra-include-dirs, extra-lib-dirs
-
-        Also check out: https://docs.haskellstack.org/en/stable/yaml_configuration
-
-        !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
+        Stack manages GHC versions internally by default. In order to make it use ghcup installed GHC versions have a look at the options 'system-ghc', 'compiler-check' and 'compiler': https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
+        Additionally, you should upgrade stack only through ghcup.
      viArch:
        A_64:
          Linux_UnknownLinux:
@@ -2179,13 +2146,14 @@ ghcupDownloads:
            unknown_versioning: *stack-251-64
    2.7.1:
      viTags:
-        - old
+        - Recommended
+        - Latest
      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v271
      viPostInstall: *stack-post
      viArch:
        A_64:
          Linux_UnknownLinux:
-            unknown_versioning: &stack-271-64
+            unknown_versioning: &stack-64
              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.1/stack-2.7.1-linux-x86_64.tar.gz
              dlHash: 2bc47749ee4be5eccb52a2d4a6a00b0f3b28b92517742b40c675836d7db2777d
              dlSubdir:
@@ -2203,33 +2171,5 @@ ghcupDownloads:
              dlSubdir:
                RegexDir: "stack-.*"
          Linux_Alpine:
-            unknown_versioning: *stack-271-64
-    2.7.3:
-      viTags:
-        - Latest
-        - Recommended
-      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v273
-      viPostInstall: *stack-post
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning: &stack-273-64
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-linux-x86_64.tar.gz
-              dlHash: a6c090555fa1c64aa61c29aa4449765a51d79e870cf759cde192937cd614e72b
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Darwin:
-            unknown_versioning:
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-osx-x86_64.tar.gz
-              dlHash: 42e5000a00af44a7b26852421ac63ce75f510ad1a97742cb131107088ee9fe30
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Windows:
-            unknown_versioning:
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-windows-x86_64.tar.gz
-              dlHash: e6ba12e0ecabf0df2567d88a0d247da238bc114bcccfca4195f5e86472c9330c
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Linux_Alpine:
-            unknown_versioning: *stack-273-64
+            unknown_versioning: *stack-64

--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,33 +1,28 @@
-cabal-version:      3.0
-name:               ghcup
-version:            0.1.17
-license:            LGPL-3.0-only
-license-file:       LICENSE
-copyright:          Julian Ospald 2020
-maintainer:         hasufell@posteo.de
-author:             Julian Ospald
-homepage:           https://gitlab.haskell.org/haskell/ghcup-hs
-bug-reports:        https://gitlab.haskell.org/haskell/ghcup-hs/issues
-synopsis:           ghc toolchain installer
+cabal-version:   3.0
+name:            ghcup
+version:         0.1.15.2
+license:         LGPL-3.0-only
+license-file:    LICENSE
+copyright:       Julian Ospald 2020
+maintainer:      hasufell@posteo.de
+author:          Julian Ospald
+homepage:        https://gitlab.haskell.org/haskell/ghcup-hs
+bug-reports:     https://gitlab.haskell.org/haskell/ghcup-hs/issues
+synopsis:        ghc toolchain installer
 description:
  A rewrite of the shell script ghcup, for providing
  a more stable user experience and exposing an API.

-category:           System
-build-type:         Simple
+category:        System
+build-type:      Simple
 extra-doc-files:
-  data/config.yaml
-  data/metadata/ghcup-0.0.4.yaml
-  data/metadata/ghcup-0.0.5.yaml
-  data/metadata/ghcup-0.0.6.yaml
-  docs/CHANGELOG.md
-  docs/HACKING.md
-  docs/RELEASING.md
+  CHANGELOG.md
+  config.yaml
+  ghcup-0.0.4.yaml
+  ghcup-0.0.5.yaml
+  HACKING.md
  README.md
-
-extra-source-files:
-  data/build_mk/cross
-  data/build_mk/default
+  RELEASING.md

 source-repository head
  type:     git
@@ -47,6 +42,11 @@ flag internal-downloader
  default:     False
  manual:      True

+flag tar
+  description: Use tar-bytestring instead of libarchive.
+  default:     False
+  manual:      True
+
 library
  exposed-modules:
    GHCup
@@ -82,6 +82,7 @@ library
    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
+    Strict
    StrictData
    TupleSections
    TypeApplications
@@ -99,24 +100,27 @@ library
    , base16-bytestring     >=0.1.1.6    && <1.1
    , binary                ^>=0.8.6.0
    , bytestring            ^>=0.10
-    , Cabal
    , case-insensitive      ^>=1.2.1.0
    , casing                ^>=0.1.4.1
+    , concurrent-output     ^>=1.10.11
    , containers            ^>=0.6
    , cryptohash-sha256     ^>=0.11.101.0
    , deepseq               ^>=1.4.4.0
    , directory             ^>=1.3.6.0
    , disk-free-space       ^>=0.1.0.1
+    , extra                 ^>=1.7.9
    , filepath              ^>=1.4.2.1
+    , generics-sop          ^>=0.5
    , haskus-utils-types    ^>=1.5
    , haskus-utils-variant  >=3.0        && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.0.0
    , lzma-static           ^>=5.2.5.3
    , megaparsec            >=8.0.0      && <9.1
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2        && <0.5
+    , optics-vl             ^>=0.2
    , os-release            ^>=1.0.0
+    , parsec                ^>=3.1
    , pretty                ^>=1.1.3.1
    , pretty-terminal       ^>=0.1.0.0
    , regex-posix           ^>=0.96
@@ -125,6 +129,7 @@ library
    , safe-exceptions       ^>=0.1
    , split                 ^>=0.2.3.4
    , strict-base           ^>=0.4
+    , string-interpolate    >=0.2.0.0    && <0.4
    , template-haskell      >=2.7        && <2.18
    , temporary             ^>=1.3
    , text                  ^>=1.2.4.0
@@ -133,9 +138,12 @@ library
    , unliftio-core         ^>=0.2.0.1
    , unordered-containers  ^>=0.2.10.0
    , uri-bytestring        ^>=0.3.2.2
+    , utf8-string           ^>=1.0
    , vector                ^>=0.12
    , versions              >=4.0.1      && <5.1
    , word8                 ^>=0.1.3
+    , yaml                  ^>=0.11.4.0
+    , zip                   ^>=1.7.1
    , zlib                  ^>=0.6.2.2

  if (flag(internal-downloader) && !os(windows))
@@ -147,6 +155,13 @@ library
      , io-streams             >=1.5.2.1
      , terminal-progress-bar  >=0.4.1

+  if flag(tar)
+    cpp-options:   -DTAR
+    build-depends: tar
+
+  else
+    build-depends: libarchive ^>=3.0.0.0
+
  if os(windows)
    cpp-options:   -DIS_WINDOWS
    other-modules: GHCup.Utils.File.Windows
@@ -157,13 +172,11 @@ library
      , Win32    ^>=2.10

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

@@ -182,6 +195,7 @@ executable ghcup
    PackageImports
    RecordWildCards
    ScopedTypeVariables
+    Strict
    StrictData
    TupleSections

@@ -190,20 +204,14 @@ executable ghcup
    -fwarn-incomplete-record-updates -threaded

  build-depends:
-    , aeson                 >=1.4      && <1.6
-    , aeson-pretty          ^>=0.8.8
-    , async                 ^>=2.2.3
    , base                  >=4.13     && <5
    , bytestring            ^>=0.10
-    , cabal-plan            ^>=0.7.2
    , containers            ^>=0.6
-    , deepseq               ^>=1.4
    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.0.0
    , megaparsec            >=8.0.0    && <9.1
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
    , optparse-applicative  >=0.15.1.0 && <0.17
    , pretty                ^>=1.1.3.1
@@ -211,6 +219,7 @@ executable ghcup
    , resourcet             ^>=1.2.2
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
+    , string-interpolate    >=0.2.0.0  && <0.4
    , template-haskell      >=2.7      && <2.18
    , text                  ^>=1.2.4.0
    , uri-bytestring        ^>=0.3.2.2
@@ -224,7 +233,7 @@ executable ghcup
    cpp-options:   -DBRICK
    other-modules: BrickMain
    build-depends:
-      , brick         ^>=0.64
+      , brick         >=0.5    && <0.62
      , transformers  ^>=0.5
      , vector        ^>=0.12
      , vty           >=5.28.2 && <5.34
@@ -232,6 +241,12 @@ executable ghcup
  if os(windows)
    cpp-options: -DIS_WINDOWS

+  if flag(tar)
+    cpp-options: -DTAR
+
+  else
+    build-depends: libarchive ^>=3.0.0.0
+
 executable ghcup-gen
  main-is:            Main.hs
  hs-source-dirs:     app/ghcup-gen
@@ -246,6 +261,7 @@ executable ghcup-gen
    QuasiQuotes
    RecordWildCards
    ScopedTypeVariables
+    Strict
    StrictData
    TupleSections
    TypeApplications
@@ -263,24 +279,32 @@ executable ghcup-gen
    , filepath              ^>=1.4.2.1
    , ghcup
    , haskus-utils-variant  >=3.0      && <3.2
-    , HsYAML-aeson          ^>=0.2.0.0
-    , libarchive            ^>=3.0.0.0
+    , monad-logger          ^>=0.3.31
    , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2      && <0.5
    , optparse-applicative  >=0.15.1.0 && <0.17
    , pretty                ^>=1.1.3.1
    , pretty-terminal       ^>=0.1.0.0
    , regex-posix           ^>=0.96
    , resourcet             ^>=1.2.2
    , safe-exceptions       ^>=0.1
+    , string-interpolate    >=0.2.0.0  && <0.4
    , text                  ^>=1.2.4.0
    , transformers          ^>=0.5
+    , uri-bytestring        ^>=0.3.2.2
    , versions              >=4.0.1    && <5.1
+    , yaml                  ^>=0.11.4.0
+
+  if flag(tar)
+    cpp-options:   -DTAR
+    build-depends: tar
+
+  else
+    build-depends: libarchive ^>=3.0.0.0

 test-suite ghcup-test
  type:               exitcode-stdio-1.0
  main-is:            Main.hs
-  build-tool-depends: hspec-discover:hspec-discover -any
  hs-source-dirs:     test
  other-modules:
    GHCup.ArbitraryTypes
--- a/test/golden/GHCupInfo.json
+++ b/test/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -1,7 +1,10 @@
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}

@@ -31,11 +34,10 @@ import           GHCup.Download.Utils
 #endif
 import           GHCup.Errors
 import           GHCup.Types
-import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
+import           GHCup.Types.Optics
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Version

@@ -45,6 +47,7 @@ import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
@@ -52,31 +55,29 @@ import           Data.Aeson
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
 #if defined(INTERNAL_DOWNLOADER)
-import           Data.CaseInsensitive           ( mk )
+import           Data.CaseInsensitive           ( CI )
 #endif
+import           Data.List.Extra
 import           Data.Maybe
-import           Data.List
+import           Data.String.Interpolate
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
-import           Data.Versions
-import           Data.Word8              hiding ( isSpace )
-import           Haskus.Utils.Variant.Excepts
 #if defined(INTERNAL_DOWNLOADER)
-import           Network.Http.Client     hiding ( URL )
+import           Data.Time.Format
 #endif
+import           Data.Versions
+import           Data.Word8
+import           GHC.IO.Exception
+import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
-import           Safe
 import           System.Directory
 import           System.Environment
-import           System.Exit
 import           System.FilePath
 import           System.IO.Error
-import           System.IO.Temp
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

 import qualified Crypto.Hash.SHA256            as SHA256
@@ -84,10 +85,12 @@ 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
+#if defined(INTERNAL_DOWNLOADER)
+import qualified Data.CaseInsensitive          as CI
+#endif
 import qualified Data.Text                     as T
-import qualified Data.Text.IO                  as T
 import qualified Data.Text.Encoding            as E
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y



@@ -104,32 +107,32 @@ import qualified Data.YAML.Aeson               as Y
 getDownloadsF :: ( FromJSONKey Tool
                 , FromJSONKey Version
                 , FromJSON VersionInfo
-                 , MonadReader env m
-                 , HasSettings env
-                 , HasDirs env
                 , MonadIO m
                 , MonadCatch m
-                 , HasLog env
+                 , MonadLogger m
                 , MonadThrow m
                 , MonadFail m
-                 , MonadMask m
                 )
-              => Excepts
-                   '[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
+              => Settings
+              -> Dirs
+              -> Excepts
+                   '[JSONError , DownloadFailed , FileDoesNotExistError]
                   m
                   GHCupInfo
-getDownloadsF = do
-  Settings { urlSource } <- lift getSettings
+getDownloadsF settings@Settings{ urlSource } dirs = do
  case urlSource of
-    GHCupURL -> liftE $ getBase ghcupURL
-    (OwnSource url) -> liftE $ getBase url
+    GHCupURL -> liftE $ getBase dirs settings
+    (OwnSource url) -> do
+      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 ghcupURL
+      base <- liftE $ getBase dirs settings
      pure (mergeGhcupInfo base ext)
    (AddSource (Right uri)) -> do
-      base <- liftE $ getBase ghcupURL
-      ext  <- liftE $ getBase 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)

    where
@@ -146,165 +149,169 @@ getDownloadsF = do
    in GHCupInfo tr newDownloads newGlobalTools


-yamlFromCache :: (MonadReader env m, HasDirs env) => URI -> m FilePath
-yamlFromCache uri = do
-  Dirs{..} <- getDirs
-  pure (cacheDir </> (T.unpack . decUTF8Safe . urlBaseName . view pathL' $ uri))
+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
+  let yaml_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError yaml_file)
+    $ liftIO
+    $ L.readFile yaml_file
+  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)


-etagsFile :: FilePath -> FilePath
-etagsFile = (<.> "etags")
-
-
-getBase :: ( MonadReader env m
-           , HasDirs env
-           , HasSettings env
-           , MonadFail m
-           , MonadIO m
-           , MonadCatch m
-           , HasLog env
-           , MonadMask m
-           )
-        => URI
-        -> Excepts '[GPGError, DigestError, JSONError, FileDoesNotExistError] m GHCupInfo
-getBase uri = do
-  Settings { noNetwork, downloader } <- lift getSettings
-
-  -- try to download yaml... usually this writes it into cache dir,
-  -- but in some cases not (e.g. when using file://), so we honour
-  -- the return filepath, if any
-  mYaml <- if noNetwork && view (uriSchemeL' % schemeBSL') uri /= "file" -- for file://, let it fall through
-           then pure Nothing
-           else handleIO (\e -> lift (warnCache (displayException e) downloader) >> pure Nothing)
-               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> lift (warnCache (prettyShow e) downloader) >> pure Nothing)
-               . fmap Just
-               . smartDl
-               $ uri
-
-  -- if we didn't get a filepath from the download, use the cached yaml
-  actualYaml <- maybe (lift $ yamlFromCache uri) pure mYaml
-  yamlContents <- liftIOException doesNotExistErrorType (FileDoesNotExistError actualYaml) $ liftIO $ L.readFile actualYaml
-  lift $ logDebug $ "Decoding yaml at: " <> T.pack actualYaml
-
-  liftE
-    . onE_ (onError actualYaml)
-    . lE' @_ @_ @'[JSONError] JSONDecodeError
-    . first (\(_, e) -> unlines [e, "Consider removing " <> actualYaml <> " manually."])
-    . Y.decode1
-    $ yamlContents
- where
-  -- On error, remove the etags file and set access time to 0. This should ensure the next invocation
-  -- may re-download and succeed.
-  onError :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
-  onError fp = do
-    let efp = etagsFile fp
-    handleIO (\e -> logWarn $ "Couldn't remove file " <> T.pack efp <> ", error was: " <> T.pack (displayException e))
-      (hideError doesNotExistErrorType $ rmFile efp)
-    liftIO $ hideError doesNotExistErrorType $ setAccessTime fp (posixSecondsToUTCTime (fromIntegral @Int 0))
-
-  warnCache :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> Downloader -> m ()
-  warnCache s downloader' = do
-    let tryDownloder = case downloader' of
-                         Curl -> "Wget"
-                         Wget -> "Curl"
-#if defined(INTERNAL_DOWNLOADER)
-                         Internal -> "Curl"
-#endif
-    logWarn $ "Could not get download info, trying cached version (this may not be recent!)" <> "\n" <>
-      "If this problem persists, consider switching downloader via: " <> "\n    " <>
-      "ghcup config set downloader " <> tryDownloder
-    logDebug $ "Error was: " <> T.pack s
-
+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 dirs)
+  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
+    where
  -- First check if the json file is in the ~/.ghcup/cache dir
  -- and check it's access time. If it has been accessed within the
  -- last 5 minutes, just reuse it.
  --
+  -- If not, then send a HEAD request and check for modification time.
+  -- Only download the file if the modification time is newer
+  -- than the local file.
+  --
  -- Always save the local file with the mod time of the remote file.
-  smartDl :: forall m1 env1
-           . ( MonadReader env1 m1
-             , HasDirs env1
-             , HasSettings env1
-             , MonadCatch m1
+  smartDl :: forall m1
+           . ( MonadCatch m1
             , MonadIO m1
             , MonadFail m1
-             , HasLog env1
-             , MonadMask m1
+             , MonadLogger m1
             )
          => URI
          -> Excepts
-               '[ DownloadFailed
-                , DigestError
-                , GPGError
+               '[ FileDoesNotExistError
+                , HTTPStatusError
+                , URIParseError
+                , UnsupportedScheme
+                , NoLocationHeader
+                , TooManyRedirs
+                , ProcessError
                ]
               m1
-               FilePath
+               L.ByteString
  smartDl uri' = do
-    json_file <- lift $ yamlFromCache uri'
-    let scheme = view (uriSchemeL' % schemeBSL') uri'
-    e <- liftIO $ doesFileExist json_file
-    currentTime <- liftIO getCurrentTime
-    Dirs { cacheDir } <- lift getDirs
+    let path = view pathL' uri'
+    let json_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
+    e         <- liftIO $ doesFileExist json_file
+    if e
+      then do
+        accessTime <- liftIO $ getAccessTime json_file
+        currentTime <- liftIO getCurrentTime

-       -- for local files, let's short-circuit and ignore access time
-    if | scheme == "file" -> liftE $ download uri' Nothing Nothing cacheDir Nothing True
-       | e -> do
-          accessTime <- liftIO $ getAccessTime json_file
+        -- access time won't work on most linuxes, but we can try regardless
+        if (utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300
+          then do -- no access in last 5 minutes, re-check upstream mod time
+            getModTime >>= \case
+              Just modTime -> do
+                fileMod <- liftIO $ getModificationTime json_file
+                if modTime > fileMod
+                  then dlWithMod modTime json_file
+                  else liftIO $ L.readFile json_file
+              Nothing -> do
+                lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
+                dlWithoutMod json_file
+          else -- access in less than 5 minutes, re-use file
+               liftIO $ L.readFile json_file
+      else do
+        getModTime >>= \case
+          Just modTime -> dlWithMod modTime json_file
+          Nothing -> do
+            -- although we don't know last-modified, we still save
+            -- it to a file, so we might use it in offline mode
+            lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
+            dlWithoutMod json_file

-          -- access time won't work on most linuxes, but we can try regardless
-          if | ((utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300) ->
-                -- no access in last 5 minutes, re-check upstream mod time
-                dlWithMod currentTime json_file
-             | otherwise -> pure json_file
-       | otherwise -> dlWithMod currentTime json_file
   where
    dlWithMod modTime json_file = do
-      let (dir, fn) = splitFileName json_file
-      f <- liftE $ download uri' (Just $ over pathL' (<> ".sig") uri') Nothing dir (Just fn) True
-      liftIO $ setModificationTime f modTime
-      liftIO $ setAccessTime f modTime
-      pure f
+      bs <- liftE $ downloadBS downloader uri'
+      liftIO $ writeFileWithModTime modTime json_file bs
+      pure bs
+    dlWithoutMod json_file = do
+      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


-getDownloadInfo :: ( MonadReader env m
-                   , HasPlatformReq env
-                   , HasGHCupInfo env
-                   )
-                => Tool
+    getModTime = do
+#if !defined(INTERNAL_DOWNLOADER)
+      pure Nothing
+#else
+      headers <-
+        handleIO (\_ -> pure mempty)
+        $ liftE
+        $ ( catchAllE
+              (\_ ->
+                pure mempty :: Excepts '[] m1 (M.Map (CI ByteString) ByteString)
+              )
+          $ getHead uri'
+          )
+      pure $ parseModifiedHeader headers
+
+  parseModifiedHeader :: (M.Map (CI ByteString) ByteString) -> Maybe UTCTime
+  parseModifiedHeader headers =
+    (M.lookup (CI.mk "Last-Modified") headers) >>= \h -> parseTimeM
+      True
+      defaultTimeLocale
+      "%a, %d %b %Y %H:%M:%S %Z"
+      (T.unpack . decUTF8Safe $ h)
+
+#endif
+
+  writeFileWithModTime :: UTCTime -> FilePath -> L.ByteString -> IO ()
+  writeFileWithModTime utctime path content = do
+    L.writeFile path content
+    setModificationTime path utctime
+
+
+getDownloadInfo :: Tool
                -> Version
                -- ^ tool version
-                -> Excepts
-                     '[NoDownload]
-                     m
-                     DownloadInfo
-getDownloadInfo t v = do
-  (PlatformRequest a p mv) <- lift getPlatformReq
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+                -> PlatformRequest
+                -> GHCupDownloads
+                -> Either NoDownload DownloadInfo
+getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
+  (Left NoDownload)
+  Right
+  (case p of
+    -- non-musl won't work on alpine
+    Linux Alpine -> with_distro <|> without_distro_ver
+    _            -> with_distro <|> without_distro_ver <|> without_distro
+  )

-  let distro_preview f g =
-        let platformVersionSpec =
-              preview (ix t % ix v % viArch % ix a % ix (f p)) dls
-            mv' = g mv
-        in  fmap snd
-              .   find
-                    (\(mverRange, _) -> maybe
-                      (isNothing mv')
-                      (\range -> maybe False (`versionRange` range) mv')
-                      mverRange
-                    )
-              .   M.toList
-              =<< platformVersionSpec
-      with_distro        = distro_preview id id
-      without_distro_ver = distro_preview id (const Nothing)
-      without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
+ where
+  with_distro        = distro_preview id id
+  without_distro_ver = distro_preview id (const Nothing)
+  without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)

-  maybe
-    (throwE NoDownload)
-    pure
-    (case p of
-      -- non-musl won't work on alpine
-      Linux Alpine -> with_distro <|> without_distro_ver
-      _            -> with_distro <|> without_distro_ver <|> without_distro
-    )
+  distro_preview f g =
+    let platformVersionSpec =
+          preview (ix t % ix v % viArch % ix a % ix (f p)) dls
+        mv' = g mv
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec


 -- | Tries to download from the given http or https url
@@ -314,301 +321,114 @@ getDownloadInfo t v = do
 --   2. otherwise create a random file
 --
 -- The file must not exist.
-download :: ( MonadReader env m
-            , HasSettings env
-            , HasDirs env
-            , MonadMask m
+download :: ( MonadMask m
            , MonadThrow m
-            , HasLog env
+            , MonadLogger m
            , MonadIO m
            )
-         => URI
-         -> Maybe URI         -- ^ URI for gpg sig
-         -> Maybe T.Text      -- ^ expected hash
-         -> FilePath          -- ^ destination dir (ignored for file:// scheme)
+         => Settings
+         -> DownloadInfo
+         -> FilePath          -- ^ destination dir
         -> Maybe FilePath    -- ^ optional filename
-         -> Bool              -- ^ whether to read an write etags
-         -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
-download uri gpgUri eDigest dest mfn etags
+         -> Excepts '[DigestError , DownloadFailed] m FilePath
+download settings@Settings{ downloader } dli dest mfn
  | scheme == "https" = dl
  | scheme == "http"  = dl
-  | scheme == "file"  = do
-      let destFile' = T.unpack . decUTF8Safe $ view pathL' uri
-      lift $ logDebug $ "using local file: " <> T.pack destFile'
-      forM_ eDigest (liftE . flip checkDigest destFile')
-      pure destFile'
+  | scheme == "file"  = cp
  | otherwise = throwE $ DownloadFailed (variantFromValue UnsupportedScheme)

 where
-  scheme = view (uriSchemeL' % schemeBSL') uri
+  scheme = view (dlUri % uriSchemeL' % schemeBSL') dli
+  cp     = do
+    -- destination dir must exist
+    liftIO $ createDirRecursive' dest
+    let destFile = getDestFile
+    let fromFile = T.unpack . decUTF8Safe $ path
+    liftIO $ copyFile fromFile destFile
+    pure destFile
  dl = do
-    baseDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile uri mfn
-    lift $ logInfo $ "downloading: " <> (decUTF8Safe . serializeURIRef') uri <> " as file " <> T.pack baseDestFile
+    let uri' = decUTF8Safe (serializeURIRef' (view dlUri dli))
+    lift $ $(logInfo) [i|downloading: #{uri'}|]

    -- destination dir must exist
    liftIO $ createDirRecursive' dest
-
+    let destFile = getDestFile

    -- download
    flip onException
-         (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile))
-     $ catchAllE @_ @'[GPGError, ProcessError, DownloadFailed, UnsupportedScheme, DigestError] @'[DigestError, DownloadFailed, GPGError]
-          (\e' -> do
-            lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile)
-            case e' of
-              V e@GPGError {} -> throwE e
-              V e@DigestError {} -> throwE e
-              _ -> throwE (DownloadFailed e')
+         (liftIO $ hideError doesNotExistErrorType $ rmFile destFile)
+     $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
+          (\e ->
+            liftIO (hideError doesNotExistErrorType $ rmFile destFile)
+              >> (throwE . DownloadFailed $ e)
          ) $ do
-              Settings{ downloader, noNetwork, gpgSetting } <- lift getSettings
-              when noNetwork $ throwE (DownloadFailed (V NoNetwork :: V '[NoNetwork]))
-              downloadAction <- case downloader of
-                    Curl -> do
-                      o' <- liftIO getCurlOpts
-                      if etags
-                        then pure $ curlEtagsDL o'
-                        else pure $ curlDL o'
-                    Wget -> do
-                      o' <- liftIO getWgetOpts
-                      if etags
-                        then pure $ wgetEtagsDL o'
-                        else pure $ wgetDL o'
+              case downloader of
+                Curl -> do
+                  o' <- liftIO getCurlOpts
+                  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] $ exec "wget" 
+                    (o' ++ ["-O", destFile , (T.unpack . decUTF8Safe) $ serializeURIRef' $ view dlUri dli]) Nothing Nothing
 #if defined(INTERNAL_DOWNLOADER)
-                    Internal -> do
-                      if etags
-                        then pure (\fp -> liftE . internalEtagsDL fp)
-                        else pure (\fp -> liftE . internalDL fp)
-#endif
-              liftE $ downloadAction baseDestFile uri
-              case (gpgUri, gpgSetting) of
-                (_, GPGNone) -> pure ()
-                (Just gpgUri', _) -> do
-                  gpgDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile gpgUri' Nothing
-                  liftE $ flip onException
-                       (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile gpgDestFile))
-                   $ catchAllE @_ @'[GPGError, ProcessError, UnsupportedScheme, DownloadFailed] @'[GPGError]
-                        (\e -> if gpgSetting == GPGStrict then throwE (GPGError e) else lift $ logWarn $ T.pack (prettyShow (GPGError e))
-                        ) $ do
-                      o' <- liftIO getGpgOpts
-                      lift $ logDebug $ "downloading: " <> (decUTF8Safe . serializeURIRef') gpgUri' <> " as file " <> T.pack gpgDestFile
-                      liftE $ downloadAction gpgDestFile gpgUri'
-                      lift $ logInfo $ "verifying signature of: " <> T.pack baseDestFile
-                      let args = o' ++ ["--batch", "--verify", "--quiet", "--no-tty", gpgDestFile, baseDestFile]
-                      cp <- lift $ executeOut "gpg" args Nothing
-                      case cp of
-                        CapturedProcess { _exitCode = ExitFailure i, _stdErr } -> do
-                          lift $ logDebug $ decUTF8Safe' _stdErr
-                          throwE (GPGError @'[ProcessError] (V (NonZeroExit i "gpg" args)))
-                        CapturedProcess { _stdErr } -> lift $ logDebug $ decUTF8Safe' _stdErr
-                _ -> pure ()
-
-              forM_ eDigest (liftE . flip checkDigest baseDestFile)
-    pure baseDestFile
-
-  curlDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  curlDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      liftE $ lEM @_ @'[ProcessError] $ exec "curl"
-        (o' ++ ["-fL", "-o", destFileTemp, T.unpack uri']) Nothing Nothing
-      liftIO $ renameFile destFileTemp destFile
-
-  curlEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  curlEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    dh <- liftIO $ emptySystemTempFile "curl-header"
-    flip finally (try @_ @SomeException $ rmFile dh) $
-      flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-        metag <- lift $ readETag destFile
-        liftE $ lEM @_ @'[ProcessError] $ exec "curl"
-            (o' ++ (if etags then ["--dump-header", dh] else [])
-                ++ maybe [] (\t -> ["-H", "If-None-Match: " <> T.unpack t]) metag
-                ++ ["-fL", "-o", destFileTemp, T.unpack uri']) Nothing Nothing
-        headers <- liftIO $ T.readFile dh
-
-        -- this nonsense is necessary, because some older versions of curl would overwrite
-        -- the destination file when 304 is returned
-        case fmap T.words . listToMaybe . fmap T.strip . T.lines . getLastHeader $ headers of
-          Just (http':sc:_)
-            | sc == "304"
-            , T.pack "HTTP" `T.isPrefixOf` http' -> lift $ logDebug "Status code was 304, not overwriting"
-            | T.pack "HTTP" `T.isPrefixOf` http' -> do
-                lift $ logDebug $ "Status code was " <> sc <> ", overwriting"
-                liftIO $ renameFile destFileTemp destFile
-          _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
-            :: V '[MalformedHeaders]))
-
-        lift $ writeEtags destFile (parseEtags headers)
-
-  wgetDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  wgetDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
-      liftE $ lEM @_ @'[ProcessError] $ exec "wget" opts Nothing Nothing
-      liftIO $ renameFile destFileTemp destFile
-
-
-  wgetEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
-  wgetEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      metag <- lift $ readETag destFile
-      let opts = o' ++ maybe [] (\t -> ["--header", "If-None-Match: " <> T.unpack t]) metag
-                    ++ ["-q", "-S", "-O", destFileTemp , T.unpack uri']
-      CapturedProcess {_exitCode, _stdErr} <- lift $ executeOut "wget" opts Nothing
-      case _exitCode of
-        ExitSuccess -> do
-          liftIO $ renameFile destFileTemp destFile
-          lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-        ExitFailure i'
-          | i' == 8
-          , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
-                   -> do
-                        lift $ logDebug "Not modified, skipping download"
-                        lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-          | otherwise -> throwE (NonZeroExit i' "wget" opts)
-
-#if defined(INTERNAL_DOWNLOADER)
-  internalDL :: (MonadCatch m, MonadMask m, MonadIO m)
-             => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
-  internalDL destFile uri' = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
-      void $ liftE $ catchE @HTTPNotModified
-                 @'[DownloadFailed]
-            (\e@(HTTPNotModified _) ->
-              throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 e :: V '[HTTPNotModified])))
-        $ downloadToFile https host fullPath port destFileTemp mempty
-      liftIO $ renameFile destFileTemp destFile
-
-
-  internalEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
-                  => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
-  internalEtagsDL destFile uri' = do
-    let destFileTemp = tmpFile destFile
-    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
-      metag <- lift $ readETag destFile
-      let addHeaders = maybe mempty (\etag -> M.fromList [ (mk . E.encodeUtf8 . T.pack $ "If-None-Match"
-                                                         , E.encodeUtf8 etag)]) metag
-      liftE
-        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags destFile (pure $ Just etag))
-        $ do
-          r <- downloadToFile https host fullPath port destFileTemp addHeaders
-          liftIO $ renameFile destFileTemp destFile
-          lift $ writeEtags destFile (pure $ decUTF8Safe <$> getHeader r "etag")
+                Internal -> do
+                  (https, host, fullPath, port) <- liftE $ uriToQuadruple (view dlUri dli)
+                  liftE $ downloadToFile https host fullPath port destFile
 #endif

+    liftE $ checkDigest settings dli destFile
+    pure destFile

  -- Manage to find a file we can write the body into.
-  getDestFile :: Monad m => URI -> Maybe FilePath -> Excepts '[NoUrlBase] m FilePath
-  getDestFile uri' mfn' = 
-    let path = view pathL' uri'
-    in case mfn' of
-        Just fn -> pure (dest </> fn)
-        Nothing
-          | let urlBase = T.unpack (decUTF8Safe (urlBaseName path))
-          , not (null urlBase) -> pure (dest </> urlBase)
-          -- TODO: remove this once we use hpath again
-          | otherwise -> throwE $ NoUrlBase (decUTF8Safe . serializeURIRef' $ uri')
+  getDestFile :: FilePath
+  getDestFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path))) (dest </>) mfn

-  parseEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
-  parseEtags stderr = do
-    let mEtag = find (\line -> T.pack "etag:" `T.isPrefixOf` T.toLower line) . fmap T.strip . T.lines . getLastHeader $ stderr
-    case T.words <$> mEtag of
-      (Just []) -> do
-        logDebug "Couldn't parse etags, no input: "
-        pure Nothing
-      (Just [_, etag']) -> do
-        logDebug $ "Parsed etag: " <> etag'
-        pure (Just etag')
-      (Just xs) -> do
-        logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
-        pure Nothing
-      Nothing -> do
-        logDebug "No etags header found"
-        pure Nothing
-
-  writeEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
-  writeEtags destFile getTags = do
-    getTags >>= \case
-      Just t -> do
-        logDebug $ "Writing etagsFile " <> T.pack (etagsFile destFile)
-        liftIO $ T.writeFile (etagsFile destFile) t
-      Nothing ->
-        logDebug "No etags files written"
-
-  readETag :: (MonadReader env m, HasLog env, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
-  readETag fp = do
-    e <- liftIO $ doesFileExist fp
-    if e
-    then do
-      rE <- try @_ @SomeException $ liftIO $ fmap stripNewline' $ T.readFile (etagsFile fp)
-      case rE of
-        (Right et) -> do
-          logDebug $ "Read etag: " <> et
-          pure (Just et)
-        (Left _) -> do
-          logDebug "Etag file doesn't exist (yet)"
-          pure Nothing
-    else do
-      logDebug $ "Skipping and deleting etags file because destination file " <> T.pack fp <> " doesn't exist"
-      liftIO $ hideError doesNotExistErrorType $ rmFile (etagsFile fp)
-      pure Nothing
+  path        = view (dlUri % pathL') dli


 -- | Download into tmpdir or use cached version, if it exists. If filename
 -- is omitted, infers the filename from the url.
-downloadCached :: ( MonadReader env m
-                  , HasDirs env
-                  , HasSettings env
-                  , MonadMask m
+downloadCached :: ( MonadMask m
                  , MonadResource m
                  , MonadThrow m
-                  , HasLog env
+                  , MonadLogger m
                  , MonadIO m
                  , MonadUnliftIO m
                  )
-               => DownloadInfo
+               => Settings
+               -> Dirs
+               -> DownloadInfo
               -> Maybe FilePath  -- ^ optional filename
-               -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
-downloadCached dli mfn = do
-  Settings{ cache } <- lift getSettings
+               -> Excepts '[DigestError , DownloadFailed] m FilePath
+downloadCached settings@Settings{ cache } dirs dli mfn = do
  case cache of
-    True -> downloadCached' dli mfn Nothing
+    True -> downloadCached' settings dirs dli mfn
    False -> do
      tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmp mfn False
+      liftE $ download settings dli tmp mfn


-downloadCached' :: ( MonadReader env m
-                   , HasDirs env
-                   , HasSettings env
-                   , MonadMask m
+downloadCached' :: ( MonadMask m
                   , MonadThrow m
-                   , HasLog env
+                   , MonadLogger m
                   , MonadIO m
                   , MonadUnliftIO m
                   )
-                => DownloadInfo
+                => Settings
+                -> Dirs
+                -> DownloadInfo
                -> Maybe FilePath  -- ^ optional filename
-                -> Maybe FilePath  -- ^ optional destination dir (default: cacheDir)
-                -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
-downloadCached' dli mfn mDestDir = do
-  Dirs { cacheDir } <- lift getDirs
-  let destDir = fromMaybe cacheDir mDestDir
+                -> 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 = destDir </> fn
+  let cachfile = cacheDir </> fn
  fileExists <- liftIO $ doesFileExist cachfile
  if
    | fileExists -> do
-      liftE $ checkDigest (view dlHash dli) cachfile
+      liftE $ checkDigest settings dli cachfile
      pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) destDir mfn False
+    | otherwise -> liftE $ download settings dli cacheDir mfn



@@ -619,25 +439,80 @@ downloadCached' dli mfn mDestDir = do



-checkDigest :: ( MonadReader env m
-               , HasDirs env
-               , HasSettings env
-               , MonadIO m
-               , MonadThrow m
-               , HasLog env
-               )
-            => T.Text     -- ^ the hash
+
+-- | This is used for downloading the JSON.
+downloadBS :: (MonadCatch m, MonadIO m, MonadLogger m)
+           => Downloader
+           -> URI
+           -> Excepts
+                '[ FileDoesNotExistError
+                 , HTTPStatusError
+                 , URIParseError
+                 , UnsupportedScheme
+                 , NoLocationHeader
+                 , TooManyRedirs
+                 , ProcessError
+                 ]
+                m
+                L.ByteString
+downloadBS downloader uri'
+  | scheme == "https"
+  = dl True
+  | scheme == "http"
+  = dl False
+  | scheme == "file"
+  = liftIOException doesNotExistErrorType (FileDoesNotExistError $ T.unpack $ decUTF8Safe path)
+    (liftIO $ L.readFile (T.unpack $ decUTF8Safe path))
+  | otherwise
+  = throwE UnsupportedScheme
+
+ where
+  scheme = view (uriSchemeL' % schemeBSL') uri'
+  path   = view pathL' uri'
+#if defined(INTERNAL_DOWNLOADER)
+  dl https = do
+#else
+  dl _ = do
+#endif
+    lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
+    case downloader of
+      Curl -> do
+        o' <- liftIO getCurlOpts
+        let exe = "curl"
+            args = o' ++ ["-sSfL", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
+        lift (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
+      Wget -> do
+        o' <- liftIO getWgetOpts
+        let exe = "wget"
+            args = o' ++ ["-qO-", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
+        lift (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
+#if defined(INTERNAL_DOWNLOADER)
+      Internal -> do
+        (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
+        liftE $ downloadBS' https host' fullPath' port'
+#endif
+
+
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m)
+            => Settings
+            -> DownloadInfo
            -> FilePath
            -> Excepts '[DigestError] m ()
-checkDigest eDigest file = do
-  Settings{ noVerify } <- lift getSettings
+checkDigest Settings{ noVerify } dli file = do
  let verify = not noVerify
  when verify $ do
    let p' = takeFileName file
-    lift $ logInfo $ "verifying digest of: " <> T.pack p'
+    lift $ $(logInfo) [i|verifying digest of: #{p'}|]
    c <- liftIO $ L.readFile file
    cDigest <- throwEither . E.decodeUtf8' . B16.encode . SHA256.hashlazy $ c
-    when ((cDigest /= eDigest) && verify) $ throwE (DigestError file cDigest eDigest)
+    let eDigest = view dlHash dli
+    when ((cDigest /= eDigest) && verify) $ throwE (DigestError cDigest eDigest)


 -- | Get additional curl args from env. This is an undocumented option.
@@ -655,34 +530,8 @@ getWgetOpts =
    Just r  -> pure $ splitOn " " r
    Nothing -> pure []

-- | Get additional gpg args from env. This is an undocumented option.
-getGpgOpts :: IO [String]
-getGpgOpts =
-  lookupEnv "GHCUP_GPG_OPTS" >>= \case
-    Just r  -> pure $ splitOn " " r
-    Nothing -> pure []

-- | Get the url base name.
--
-- >>> urlBaseName "/foo/bar/baz"
-- "baz"
 urlBaseName :: ByteString  -- ^ the url path (without scheme and host)
            -> ByteString
 urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False

-
-- | Curl saves all intermediate connect headers as well, not just the last one, so we make an effort to take the
-- last HTTP block only. Passing '--suppress-connect-headers' would be better, but it isn't supported by all versions,
-- also see:
--   https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/213
--
-- >>> getLastHeader "\n\nHTTP/1.0 200 Connection established\n\nHTTP/1.1 304 Not Modified\n"
-- "HTTP/1.1 304 Not Modified\n"
-- >>> getLastHeader "HTTP/1.1 304 Not Modified\n"
-- "HTTP/1.1 304 Not Modified\n"
-getLastHeader :: T.Text -> T.Text
-getLastHeader = T.unlines . lastDef [] . filter (\x -> not (null x)) . splitOn [""] . fmap T.stripEnd . T.lines
-
-
-tmpFile :: FilePath -> FilePath
-tmpFile = (<.> "tmp")
--- a/lib/GHCup/Download/IOStreams.hs
+++ b/lib/GHCup/Download/IOStreams.hs
@@ -9,7 +9,9 @@ module GHCup.Download.IOStreams where

 import           GHCup.Download.Utils
 import           GHCup.Errors
+import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.File
 import           GHCup.Utils.Prelude

 import           Control.Applicative
@@ -18,7 +20,7 @@ import           Control.Monad
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.ByteString.Builder
-import           Data.CaseInsensitive           ( CI, original, mk )
+import           Data.CaseInsensitive           ( CI )
 import           Data.IORef
 import           Data.Maybe
 import           Data.Text.Read
@@ -30,6 +32,7 @@ import           Prelude                 hiding ( abs
                                                , writeFile
                                                )
 import           System.ProgressBar
+import           System.IO
 import           URI.ByteString

 import qualified Data.ByteString               as BS
@@ -64,7 +67,7 @@ downloadBS' :: MonadIO m
 downloadBS' https host path port = do
  bref <- liftIO $ newIORef (mempty :: Builder)
  let stepper bs = modifyIORef bref (<> byteString bs)
-  void $ downloadInternal False https host path port stepper (pure ()) mempty
+  downloadInternal False https host path port stepper
  liftIO (readIORef bref <&> toLazyByteString)


@@ -74,17 +77,12 @@ downloadToFile :: (MonadMask m, MonadIO m)
               -> ByteString       -- ^ path (e.g. "/my/file") including query
               -> Maybe Int        -- ^ optional port (e.g. 3000)
               -> FilePath         -- ^ destination file to create and write to
-               -> M.Map (CI ByteString) ByteString -- ^ additional headers
-               -> Excepts '[DownloadFailed, HTTPNotModified] m Response
-downloadToFile https host fullPath port destFile addHeaders = do
-  let stepper = BS.appendFile destFile
-      setup = BS.writeFile destFile mempty
-  catchAllE (\case
-              (V (HTTPStatusError i headers))
-                | i == 304
-                , Just e <- M.lookup (mk "etag") headers -> throwE $ HTTPNotModified (decUTF8Safe e)
-              v -> throwE $ DownloadFailed v
-            ) $ downloadInternal True https host fullPath port stepper setup addHeaders
+               -> Excepts '[DownloadFailed] m ()
+downloadToFile https host fullPath port destFile = do
+  fd <- liftIO $ openFile destFile WriteMode
+  let stepper = BS.hPut fd
+  flip finally (liftIO $ hClose fd)
+    $ reThrowAll DownloadFailed $ downloadInternal True https host fullPath port stepper


 downloadInternal :: MonadIO m
@@ -94,8 +92,6 @@ downloadInternal :: MonadIO m
                 -> ByteString  -- ^ path with query
                 -> Maybe Int   -- ^ optional port
                 -> (ByteString -> IO a)   -- ^ the consuming step function
-                 -> IO a                   -- ^ setup action
-                 -> M.Map (CI ByteString) ByteString -- ^ additional headers
                 -> Excepts
                      '[ HTTPStatusError
                       , URIParseError
@@ -104,21 +100,19 @@ downloadInternal :: MonadIO m
                       , TooManyRedirs
                       ]
                      m
-                      Response
+                      ()
 downloadInternal = go (5 :: Int)

 where
-  go redirs progressBar https host path port consumer setup addHeaders = do
+  go redirs progressBar https host path port consumer = do
    r <- liftIO $ withConnection' https host port action
    veitherToExcepts r >>= \case
-      Right r' ->
+      Just r' ->
        if redirs > 0 then followRedirectURL r' else throwE TooManyRedirs
-      Left res -> pure res
+      Nothing -> pure ()
   where
    action c = do
-      let q = buildRequest1 $ do
-                http GET path
-                flip M.traverseWithKey addHeaders $ \key val -> setHeader (original key) val
+      let q = buildRequest1 $ http GET path

      sendRequest c q emptyBody

@@ -127,30 +121,28 @@ downloadInternal = go (5 :: Int)
        (\r i' -> runE $ do
          let scode = getStatusCode r
          if
-            | scode >= 200 && scode < 300 -> liftIO $ downloadStream r i' >> pure (Left r)
-            | scode == 304 -> throwE $ HTTPStatusError scode (getHeaderMap r)
+            | scode >= 200 && scode < 300 -> downloadStream r i' >> pure Nothing
            | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Right r'
+              Just r' -> pure $ Just r'
              Nothing -> throwE NoLocationHeader
-            | otherwise -> throwE $ HTTPStatusError scode (getHeaderMap r)
+            | otherwise -> throwE $ HTTPStatusError scode
        )

    followRedirectURL bs = case parseURI strictURIParserOptions bs of
      Right uri' -> do
        (https', host', fullPath', port') <- liftE $ uriToQuadruple uri'
-        go (redirs - 1) progressBar https' host' fullPath' port' consumer setup addHeaders
+        go (redirs - 1) progressBar https' host' fullPath' port' consumer
      Left e -> throwE e

    downloadStream r i' = do
-      void setup
      let size = case getHeader r "Content-Length" of
            Just x' -> case decimal $ decUTF8Safe x' of
              Left  _       -> 0
              Right (r', _) -> r'
            Nothing -> 0

-      (mpb :: Maybe (ProgressBar ())) <- if progressBar
-        then Just <$> newProgressBar defStyle 10 (Progress 0 size ())
+      mpb <- if progressBar
+        then Just <$> liftIO (newProgressBar defStyle 10 (Progress 0 size ()))
        else pure Nothing

      outStream <- liftIO $ Streams.makeOutputStream
@@ -163,6 +155,79 @@ downloadInternal = go (5 :: Int)
      liftIO $ Streams.connect i' outStream


+getHead :: (MonadCatch m, MonadIO m)
+        => URI
+        -> Excepts
+             '[ HTTPStatusError
+              , URIParseError
+              , UnsupportedScheme
+              , NoLocationHeader
+              , TooManyRedirs
+              , ProcessError
+              ]
+             m
+             (M.Map (CI ByteString) ByteString)
+getHead uri' | scheme == "https" = head' True
+             | scheme == "http"  = head' False
+             | otherwise         = throwE UnsupportedScheme
+
+ where
+  scheme = view (uriSchemeL' % schemeBSL') uri'
+  head' https = do
+    (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
+    liftE $ headInternal https host' fullPath' port'
+
+
+headInternal :: MonadIO m
+             => Bool        -- ^ https?
+             -> ByteString  -- ^ host
+             -> ByteString  -- ^ path with query
+             -> Maybe Int   -- ^ optional port
+             -> Excepts
+                  '[ HTTPStatusError
+                   , URIParseError
+                   , UnsupportedScheme
+                   , TooManyRedirs
+                   , NoLocationHeader
+                   ]
+                  m
+                  (M.Map (CI ByteString) ByteString)
+headInternal = go (5 :: Int)
+
+ where
+  go redirs https host path port = do
+    r <- liftIO $ withConnection' https host port action
+    veitherToExcepts r >>= \case
+      Left r' ->
+        if redirs > 0 then followRedirectURL r' else throwE TooManyRedirs
+      Right hs -> pure hs
+   where
+
+    action c = do
+      let q = buildRequest1 $ http HEAD path
+
+      sendRequest c q emptyBody
+
+      unsafeReceiveResponse
+        c
+        (\r _ -> runE $ do
+          let scode = getStatusCode r
+          if
+            | scode >= 200 && scode < 300 -> do
+              let headers = getHeaderMap r
+              pure $ Right headers
+            | scode >= 300 && scode < 400 -> case getHeader r "Location" of
+              Just r' -> pure $ Left r'
+              Nothing -> throwE NoLocationHeader
+            | otherwise -> throwE $ HTTPStatusError scode
+        )
+
+    followRedirectURL bs = case parseURI strictURIParserOptions bs of
+      Right uri' -> do
+        (https', host', fullPath', port') <- liftE $ uriToQuadruple uri'
+        go (redirs - 1) https' host' fullPath' port'
+      Left e -> throwE e
+

 withConnection' :: Bool
                -> ByteString
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -4,6 +4,7 @@
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TypeOperators           #-}
 {-# LANGUAGE FlexibleInstances           #-}

@@ -20,20 +21,20 @@ module GHCup.Errors where

 import           GHCup.Types

+#if !defined(TAR)
 import           Codec.Archive
+#else
+import qualified Codec.Archive.Tar             as Tar
+#endif
 import           Control.Exception.Safe
-import           Data.ByteString                ( ByteString )
-import           Data.CaseInsensitive           ( CI )
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant
-import           Text.PrettyPrint               hiding ( (<>) )
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
+import           Text.PrettyPrint
+import           Text.PrettyPrint.HughesPJClass
 import           URI.ByteString

-import qualified Data.Map.Strict               as M
-import qualified Data.Text                     as T
-


    ------------------------
@@ -50,7 +51,7 @@ instance Pretty NoCompatiblePlatform where
  pPrint (NoCompatiblePlatform str') =
    text ("Could not find a compatible platform. Got: " ++ str')

-- | Unable to find a download for the requested version/distro.
+-- | Unable to find a download for the requested versio/distro.
 data NoDownload = NoDownload
  deriving Show

@@ -87,7 +88,7 @@ data UnknownArchive = UnknownArchive FilePath

 instance Pretty UnknownArchive where
  pPrint (UnknownArchive file) =
-    text $ "The archive format is unknown. We don't know how to extract the file " <> file
+    text [i|The archive format is unknown. We don't know how to extract the file "#{file}"|]

 -- | The scheme is not supported (such as ftp).
 data UnsupportedScheme = UnsupportedScheme
@@ -110,7 +111,7 @@ data TagNotFound = TagNotFound Tag Tool

 instance Pretty TagNotFound where
  pPrint (TagNotFound tag tool) =
-    text "Unable to find tag" <+> pPrint tag <+> text "of tool" <+> pPrint tool
+    text "Unable to find tag" <+> pPrint tag <+> text [i|of tool "#{tool}"|]

 -- | Unable to find the next version of a tool (the one after the currently
 -- set one).
@@ -119,7 +120,7 @@ data NextVerNotFound = NextVerNotFound Tool

 instance Pretty NextVerNotFound where
  pPrint (NextVerNotFound tool) =
-    text "Unable to find next (the one after the currently set one) version of tool" <+> pPrint tool
+    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]

 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
@@ -127,14 +128,7 @@ data AlreadyInstalled = AlreadyInstalled Tool Version

 instance Pretty AlreadyInstalled where
  pPrint (AlreadyInstalled tool ver') =
-    pPrint tool <+> text "-" <+> pPrint ver' <+> text "is already installed"
-
-- | The Directory is supposed to be empty, but wasn't.
-data DirNotEmpty = DirNotEmpty {path :: FilePath}
-
-instance Pretty DirNotEmpty where
-  pPrint (DirNotEmpty path) = do
-    text $ "The directory was expected to be empty, but isn't: " <> path
+    text [i|#{tool}-#{prettyShow ver'} is already installed|]

 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
@@ -143,7 +137,7 @@ data NotInstalled = NotInstalled Tool GHCTargetVersion

 instance Pretty NotInstalled where
  pPrint (NotInstalled tool ver) =
-    text "The version" <+> pPrint ver <+> text "of the tool" <+> pPrint tool <+> text "is not installed."
+    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]

 -- | An executable was expected to be in PATH, but was not found.
 data NotFoundInPATH = NotFoundInPATH FilePath
@@ -151,7 +145,7 @@ data NotFoundInPATH = NotFoundInPATH FilePath

 instance Pretty NotFoundInPATH where
  pPrint (NotFoundInPATH exe) =
-    text $ "The exe " <> exe <> " was not found in PATH."
+    text [i|The exe "#{exe}" was not found in PATH.|]

 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
@@ -159,7 +153,7 @@ data JSONError = JSONDecodeError String

 instance Pretty JSONError where
  pPrint (JSONDecodeError err) =
-    text $ "JSON decoding failed with: " <> err
+    text [i|JSON decoding failed with: #{err}|]

 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
@@ -168,17 +162,7 @@ data FileDoesNotExistError = FileDoesNotExistError FilePath

 instance Pretty FileDoesNotExistError where
  pPrint (FileDoesNotExistError file) =
-    text $ "File " <> file <> " does not exist."
-
-- | The file already exists
-- (e.g. when we use isolated installs with the same path).
-- (e.g. This is done to prevent any overwriting)
-data FileAlreadyExistsError = FileAlreadyExistsError FilePath
-  deriving Show
-
-instance Pretty FileAlreadyExistsError where
-  pPrint (FileAlreadyExistsError file) =
-    text $ "File " <> file <> " Already exists."
+    text [i|File "#{file}" does not exist.|]

 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
  deriving Show
@@ -188,46 +172,20 @@ instance Pretty TarDirDoesNotExist where
    text "Tar directory does not exist:" <+> pPrint dir

 -- | File digest verification failed.
-data DigestError = DigestError FilePath Text Text
+data DigestError = DigestError Text Text
  deriving Show

 instance Pretty DigestError where
-  pPrint (DigestError fp currentDigest expectedDigest) =
-    text "Digest error for" <+> text (fp <> ": expected")
-      <+> text (T.unpack expectedDigest) <+> text "but got" <+> pPrint currentDigest <+> text
-      "\nConsider removing the file in case it's cached and try again."
-
-- | File digest verification failed.
-data GPGError = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => GPGError (V xs)
-
-deriving instance Show GPGError
-
-instance Pretty GPGError where
-  pPrint (GPGError reason) = text "GPG verify failed:" <+> pPrint reason
+  pPrint (DigestError currentDigest expectedDigest) =
+    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]

 -- | Unexpected HTTP status.
-data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
+data HTTPStatusError = HTTPStatusError Int
  deriving Show

 instance Pretty HTTPStatusError where
-  pPrint (HTTPStatusError status _) =
-    text "Unexpected HTTP status:" <+> pPrint status
-
-- | Malformed headers.
-data MalformedHeaders = MalformedHeaders Text
-  deriving Show
-
-instance Pretty MalformedHeaders where
-  pPrint (MalformedHeaders h) =
-    text "Headers are malformed: " <+> pPrint h
-
-- | Unexpected HTTP status.
-data HTTPNotModified = HTTPNotModified Text
-  deriving Show
-
-instance Pretty HTTPNotModified where
-  pPrint (HTTPNotModified etag) =
-    text "Remote resource not modifed, etag was:" <+> pPrint etag
+  pPrint (HTTPStatusError status) =
+    text [i|Unexpected HTTP status: #{status}|]

 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
@@ -235,7 +193,7 @@ data NoLocationHeader = NoLocationHeader

 instance Pretty NoLocationHeader where
  pPrint NoLocationHeader =
-    text "The 'Location' header was expected during a 3xx redirect, but not found."
+    text [i|The 'Location' header was expected during a 3xx redirect, but not found.|]

 -- | Too many redirects.
 data TooManyRedirs = TooManyRedirs
@@ -243,7 +201,7 @@ data TooManyRedirs = TooManyRedirs

 instance Pretty TooManyRedirs where
  pPrint TooManyRedirs =
-    text "Too many redirections."
+    text [i|Too many redirections.|]

 -- | A patch could not be applied.
 data PatchFailed = PatchFailed
@@ -251,7 +209,7 @@ data PatchFailed = PatchFailed

 instance Pretty PatchFailed where
  pPrint PatchFailed =
-    text "A patch could not be applied."
+    text [i|A patch could not be applied.|]

 -- | The tool requirements could not be found.
 data NoToolRequirements = NoToolRequirements
@@ -259,35 +217,21 @@ data NoToolRequirements = NoToolRequirements

 instance Pretty NoToolRequirements where
  pPrint NoToolRequirements =
-    text "The Tool requirements could not be found."
+    text [i|The Tool requirements could not be found.|]

 data InvalidBuildConfig = InvalidBuildConfig Text
  deriving Show

 instance Pretty InvalidBuildConfig where
  pPrint (InvalidBuildConfig reason) =
-    text "The build config is invalid. Reason was:" <+> pPrint reason
+    text [i|The build config is invalid. Reason was: #{reason}|]

 data NoToolVersionSet = NoToolVersionSet Tool
  deriving Show

 instance Pretty NoToolVersionSet where
  pPrint (NoToolVersionSet tool) =
-    text "No version is set for tool" <+> pPrint tool <+> text "."
-
-data NoNetwork = NoNetwork
-  deriving Show
-
-instance Pretty NoNetwork where
-  pPrint NoNetwork =
-    text "A download was required or requested, but '--offline' was specified."
-
-data HadrianNotFound = HadrianNotFound
-  deriving Show
-
-instance Pretty HadrianNotFound where
-  pPrint HadrianNotFound =
-    text "Could not find Hadrian build files. Does this GHC version support Hadrian builds?"
+    text [i|No version is set for tool "#{tool}".|]


    -------------------------
@@ -295,37 +239,31 @@ instance Pretty HadrianNotFound where
    -------------------------

 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => DownloadFailed (V xs)
+data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))

 instance Pretty DownloadFailed where
  pPrint (DownloadFailed reason) =
-    case reason of
-      VMaybe (_ :: DownloadFailed) -> pPrint reason
-      _ -> text "Download failed:" <+> pPrint reason
+    text "Download failed:" <+> pPrint reason

 deriving instance Show DownloadFailed


 -- | A build failed.
-data BuildFailed = forall es . (ToVariantMaybe BuildFailed es, PopVariant BuildFailed es, Pretty (V es), Show (V es)) => BuildFailed FilePath (V es)
+data BuildFailed = forall es . Show (V es) => BuildFailed FilePath (V es)

 instance Pretty BuildFailed where
  pPrint (BuildFailed path reason) =
-    case reason of
-      VMaybe (_ :: BuildFailed) -> pPrint reason
-      _ -> text "BuildFailed failed in dir" <+> text (path <> ":") <+> pPrint reason
+    text [i|BuildFailed failed in dir "#{path}": #{reason}|]

 deriving instance Show BuildFailed


 -- | Setting the current GHC version failed.
-data GHCupSetError = forall es . (ToVariantMaybe GHCupSetError es, PopVariant GHCupSetError es, Show (V es), Pretty (V es)) => GHCupSetError (V es)
+data GHCupSetError = forall es . Show (V es) => GHCupSetError (V es)

 instance Pretty GHCupSetError where
  pPrint (GHCupSetError reason) =
-    case reason of
-      VMaybe (_ :: GHCupSetError) -> pPrint reason
-      _ -> text "Setting the current GHC version failed:" <+> pPrint reason
+    text [i|Setting the current GHC version failed: #{reason}|]

 deriving instance Show GHCupSetError

@@ -341,7 +279,7 @@ data ParseError = ParseError String

 instance Pretty ParseError where
  pPrint (ParseError reason) =
-    text "Parsing failed:" <+> pPrint reason
+    text [i|Parsing failed: #{reason}|]

 instance Exception ParseError

@@ -351,19 +289,10 @@ data UnexpectedListLength = UnexpectedListLength String

 instance Pretty UnexpectedListLength where
  pPrint (UnexpectedListLength reason) =
-    text "List length unexpected:" <+> pPrint reason
+    text [i|List length unexpected: #{reason}|]

 instance Exception UnexpectedListLength

-data NoUrlBase = NoUrlBase Text
-  deriving Show
-
-instance Pretty NoUrlBase where
-  pPrint (NoUrlBase url) =
-    text "Couldn't get a base filename from url" <+> pPrint url
-
-instance Exception NoUrlBase
-


    ------------------------
@@ -385,22 +314,23 @@ instance

 instance Pretty URIParseError where
  pPrint (MalformedScheme reason) =
-    text "Failed to parse URI. Malformed scheme:" <+> text (show reason)
+    text [i|Failed to parse URI. Malformed scheme: #{reason}|]
  pPrint MalformedUserInfo =
-    text "Failed to parse URI. Malformed user info."
+    text [i|Failed to parse URI. Malformed user info.|]
  pPrint MalformedQuery =
-    text "Failed to parse URI. Malformed query."
+    text [i|Failed to parse URI. Malformed query.|]
  pPrint MalformedFragment =
-    text "Failed to parse URI. Malformed fragment."
+    text [i|Failed to parse URI. Malformed fragment.|]
  pPrint MalformedHost =
-    text "Failed to parse URI. Malformed host."
+    text [i|Failed to parse URI. Malformed host.|]
  pPrint MalformedPort =
-    text "Failed to parse URI. Malformed port."
+    text [i|Failed to parse URI. Malformed port.|]
  pPrint MalformedPath =
-    text "Failed to parse URI. Malformed path."
+    text [i|Failed to parse URI. Malformed path.|]
  pPrint (OtherError err) =
-    text "Failed to parse URI:" <+> pPrint err
+    text [i|Failed to parse URI: #{err}|]

+#if !defined(TAR)
 instance Pretty ArchiveResult where
  pPrint ArchiveFatal = text "Archive result: fatal"
  pPrint ArchiveFailed = text "Archive result: failed"
@@ -408,6 +338,14 @@ instance Pretty ArchiveResult where
  pPrint ArchiveRetry = text "Archive result: retry"
  pPrint ArchiveOk = text "Archive result: Ok"
  pPrint ArchiveEOF = text "Archive result: EOF"
-
-instance Pretty T.Text where
-  pPrint = text . T.unpack
+#else
+instance Pretty Tar.FormatError where
+  pPrint Tar.TruncatedArchive = text "Truncated archive"
+  pPrint Tar.ShortTrailer = text "Short trailer"
+  pPrint Tar.BadTrailer = text "Bad trailer"
+  pPrint Tar.TrailingJunk = text "Trailing junk"
+  pPrint Tar.ChecksumIncorrect = text "Checksum incorrect"
+  pPrint Tar.NotTarFormat = text "Not a tar format"
+  pPrint Tar.UnrecognisedTarFormat = text "Unrecognised tar format"
+  pPrint Tar.HeaderBadNumericEncoding = text "Header has bad numeric encoding"
+#endif
--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -20,20 +20,20 @@ module GHCup.Platform where

 import           GHCup.Errors
 import           GHCup.Types
-import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ

 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.Foldable
 import           Data.Maybe
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant.Excepts
@@ -58,7 +58,7 @@ import qualified Data.Text.IO                  as T


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


-getPlatform :: (Alternative m, MonadReader env m, HasLog env, MonadCatch m, MonadIO m, MonadFail m)
+getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
            => Excepts
                 '[NoCompatiblePlatform, DistroNotFound]
                 m
@@ -108,7 +108,7 @@ getPlatform = do
      pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
    "mingw32" -> pure PlatformResult { _platform = Windows, _distroVersion = Nothing }
    what -> throwE $ NoCompatiblePlatform what
-  lift $ logDebug $ "Identified Platform as: " <> T.pack (prettyShow pfr)
+  lift $ $(logDebug) [i|Identified Platform as: #{prettyShow pfr}|]
  pure pfr
 where
  getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
@@ -142,7 +142,9 @@ getLinuxDistro = do
        | otherwise                -> UnknownLinux
  pure (distro, parsedVer)
 where
-  hasWord t = any (\x -> match (regex x) (T.unpack t))
+  hasWord t matches = foldr (\x y -> match (regex x) (T.unpack t) || y)
+                            False
+                            matches
   where
    regex x = makeRegexOpts compIgnoreCase execBlank ([s|\<|] ++ x ++ [s|\>|])

--- a/lib/GHCup/Requirements.hs
+++ b/lib/GHCup/Requirements.hs
@@ -60,10 +60,9 @@ getCommonRequirements pr tr =
 prettyRequirements :: Requirements -> T.Text
 prettyRequirements Requirements {..} =
  let d = if not . null $ _distroPKGs
-        then "\n  Please ensure the following distro packages "
-          <> "are installed before continuing (you can exit ghcup "
-          <> "and return at any time): "
-          <> T.intercalate " " _distroPKGs
+        then
+          "\n  Please install the following distro packages: "
+            <> T.intercalate " " _distroPKGs
        else ""
      n = if not . T.null $ _notes then "\n  Note: " <> _notes else ""
  in  "System requirements " <> d <> n
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -1,12 +1,7 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
-{-# LANGUAGE BangPatterns      #-}
-{-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DuplicateRecordFields #-}

 {-|
 Module      : GHCup.Types
@@ -25,17 +20,20 @@ module GHCup.Types
  )
  where

-import           Control.DeepSeq                ( NFData, rnf )
+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

@@ -62,8 +60,6 @@ data GHCupInfo = GHCupInfo
  }
  deriving (Show, GHC.Generic)

-instance NFData GHCupInfo
-


    -------------------------
@@ -83,8 +79,6 @@ data Requirements = Requirements
  }
  deriving (Show, GHC.Generic)

-instance NFData Requirements
-



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

-instance Pretty Tool where
-  pPrint GHC = text "ghc"
-  pPrint Cabal = text "cabal"
-  pPrint GHCup = text "ghcup"
-  pPrint HLS = text "hls"
-  pPrint Stack = text "stack"
-
-instance NFData Tool
-
 data GlobalTool = ShimGen
  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)

-instance NFData GlobalTool
-

 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
@@ -140,20 +123,16 @@ data VersionInfo = VersionInfo
  }
  deriving (Eq, GHC.Generic, Show)

-instance NFData VersionInfo
-

 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
         | Recommended
         | Prerelease
         | Base PVP
-         | Old                -- ^ old versions are hidden by default in TUI
+         | Old                -- ^ old version are hidden by default in TUI
         | UnknownTag String  -- ^ used for upwardscompat
         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance

-instance NFData Tag
-
 tagToString :: Tag -> String
 tagToString Recommended        = "recommended"
 tagToString Latest             = "latest"
@@ -180,8 +159,6 @@ data Architecture = A_64
                  | A_ARM64
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData Architecture
-
 archToString :: Architecture -> String
 archToString A_64 = "x86_64"
 archToString A_32 = "i386"
@@ -204,8 +181,6 @@ data Platform = Linux LinuxDistro
              -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData Platform
-
 platformToString :: Platform -> String
 platformToString (Linux distro) = "linux-" ++ distroToString distro
 platformToString Darwin = "darwin"
@@ -231,12 +206,10 @@ data LinuxDistro = Debian
                 -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData LinuxDistro
-
 distroToString :: LinuxDistro -> String
 distroToString Debian = "debian"
 distroToString Ubuntu = "ubuntu"
-distroToString Mint = "mint"
+distroToString Mint= "mint"
 distroToString Fedora = "fedora"
 distroToString CentOS = "centos"
 distroToString RedHat = "redhat"
@@ -259,7 +232,6 @@ data DownloadInfo = DownloadInfo
  }
  deriving (Eq, Ord, GHC.Generic, Show)

-instance NFData DownloadInfo



@@ -273,8 +245,6 @@ data TarDir = RealDir FilePath
            | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
            deriving (Eq, Ord, GHC.Generic, Show)

-instance NFData TarDir
-
 instance Pretty TarDir where
  pPrint (RealDir path) = text path
  pPrint (RegexDir regex) = text regex
@@ -287,10 +257,6 @@ data URLSource = GHCupURL
               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
               deriving (GHC.Generic, Show)

-instance NFData URLSource
-instance NFData (URIRef Absolute) where
-  rnf (URI !_ !_ !_ !_ !_) = ()
-

 data UserSettings = UserSettings
  { uCache       :: Maybe Bool
@@ -300,50 +266,11 @@ data UserSettings = UserSettings
  , uDownloader  :: Maybe Downloader
  , uKeyBindings :: Maybe UserKeyBindings
  , uUrlSource   :: Maybe URLSource
-  , uNoNetwork   :: Maybe Bool
-  , uGPGSetting  :: Maybe GPGSetting
  }
  deriving (Show, GHC.Generic)

 defaultUserSettings :: UserSettings
-defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
-
-fromSettings :: Settings -> Maybe KeyBindings -> UserSettings
-fromSettings Settings{..} Nothing =
-  UserSettings {
-      uCache = Just cache
-    , uNoVerify = Just noVerify
-    , uVerbose = Just verbose
-    , uKeepDirs = Just keepDirs
-    , uDownloader = Just downloader
-    , uNoNetwork = Just noNetwork
-    , uKeyBindings = Nothing
-    , uUrlSource = Just urlSource
-    , uGPGSetting = Just gpgSetting
-  }
-fromSettings Settings{..} (Just KeyBindings{..}) =
-  let ukb = UserKeyBindings
-            { kUp           = Just bUp        
-            , kDown         = Just bDown      
-            , kQuit         = Just bQuit      
-            , kInstall      = Just bInstall   
-            , kUninstall    = Just bUninstall 
-            , kSet          = Just bSet       
-            , kChangelog    = Just bChangelog 
-            , kShowAll      = Just bShowAllVersions
-            , kShowAllTools = Just bShowAllTools
-            }
-  in UserSettings {
-      uCache = Just cache
-    , uNoVerify = Just noVerify
-    , uVerbose = Just verbose
-    , uKeepDirs = Just keepDirs
-    , uDownloader = Just downloader
-    , uNoNetwork = Just noNetwork
-    , uKeyBindings = Just ukb
-    , uUrlSource = Just urlSource
-    , uGPGSetting = Just gpgSetting
-  }
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing

 data UserKeyBindings = UserKeyBindings
  { kUp        :: Maybe Key
@@ -371,9 +298,6 @@ data KeyBindings = KeyBindings
  }
  deriving (Show, GHC.Generic)

-instance NFData KeyBindings
-instance NFData Key
-
 defaultKeyBindings :: KeyBindings
 defaultKeyBindings = KeyBindings
  { bUp = KUp
@@ -393,20 +317,7 @@ data AppState = AppState
  , keyBindings :: KeyBindings
  , ghcupInfo :: GHCupInfo
  , pfreq :: PlatformRequest
-  , loggerConfig :: LoggerConfig
-  } deriving (Show, GHC.Generic)
-
-instance NFData AppState
-
-data LeanAppState = LeanAppState
-  { settings :: Settings
-  , dirs :: Dirs
-  , keyBindings :: KeyBindings
-  , loggerConfig :: LoggerConfig
-  } deriving (Show, GHC.Generic)
-
-instance NFData LeanAppState
-
+  } deriving (Show)

 data Settings = Settings
  { cache      :: Bool
@@ -415,48 +326,29 @@ data Settings = Settings
  , downloader :: Downloader
  , verbose    :: Bool
  , urlSource  :: URLSource
-  , noNetwork  :: Bool
-  , gpgSetting :: GPGSetting
-  , noColor    :: Bool -- this also exists in LoggerConfig
  }
  deriving (Show, GHC.Generic)

-instance NFData Settings
-
 data Dirs = Dirs
  { baseDir  :: FilePath
  , binDir   :: FilePath
  , cacheDir :: FilePath
  , logsDir  :: FilePath
  , confDir  :: FilePath
-  , recycleDir :: FilePath -- mainly used on windows
  }
-  deriving (Show, GHC.Generic)
-
-instance NFData Dirs
+  deriving Show

 data KeepDirs = Always
              | Errors
              | Never
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData KeepDirs
+  deriving (Eq, Show, Ord)

 data Downloader = Curl
                | Wget
 #if defined(INTERNAL_DOWNLOADER)
                | Internal
 #endif
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData Downloader
-
-data GPGSetting = GPGStrict
-                | GPGLax
-                | GPGNone
-  deriving (Eq, Show, Ord, GHC.Generic)
-
-instance NFData GPGSetting
+  deriving (Eq, Show, Ord)

 data DebugInfo = DebugInfo
  { diBaseDir  :: FilePath
@@ -479,9 +371,7 @@ data PlatformResult = PlatformResult
  { _platform      :: Platform
  , _distroVersion :: Maybe Versioning
  }
-  deriving (Eq, Show, GHC.Generic)
-
-instance NFData PlatformResult
+  deriving (Eq, Show)

 platResToString :: PlatformResult -> String
 platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
@@ -497,9 +387,7 @@ data PlatformRequest = PlatformRequest
  , _rPlatform :: Platform
  , _rVersion  :: Maybe Versioning
  }
-  deriving (Eq, Show, GHC.Generic)
-
-instance NFData PlatformRequest
+  deriving (Eq, Show)

 pfReqToString :: PlatformRequest -> String
 pfReqToString (PlatformRequest arch plat ver) =
@@ -546,8 +434,6 @@ data VersionCmp = VR_gt Versioning
                | VR_eq Versioning
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData VersionCmp
-

 -- | A version range. Supports && and ||, but not  arbitrary
 -- combinations. This is a little simplified.
@@ -555,7 +441,6 @@ data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
                  | OrRange (NonEmpty VersionCmp) VersionRange
  deriving (Eq, GHC.Generic, Ord, Show)

-instance NFData VersionRange

 instance Pretty Versioning where
  pPrint = text . T.unpack . prettyV
@@ -563,26 +448,15 @@ instance Pretty Versioning where
 instance Pretty Version where
  pPrint = text . T.unpack . prettyVer

-instance Show (a -> b) where
-  show _ = "<function>"

-instance Show (IO ()) where
-  show _ = "<io>"
+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 (<|>) #-}


-data LogLevel = Warn
-              | Info
-              | Debug
-              | Error
-  deriving (Eq, Ord, Show)
+instance MonadLogger m => MonadLogger (Excepts e m) where
+  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d

-data LoggerConfig = LoggerConfig
-  { lcPrintDebug   :: Bool            -- ^ whether to print debug in colorOutter
-  , consoleOutter  :: T.Text -> IO () -- ^ how to write the console output
-  , fileOutter     :: T.Text -> IO () -- ^ how to write the file output
-  , fancyColors    :: Bool
-  }
-  deriving Show

-instance NFData LoggerConfig where
-  rnf (LoggerConfig !lcPrintDebug !_ !_ !fancyColors) = rnf (lcPrintDebug, fancyColors)
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@@ -24,8 +24,6 @@ module GHCup.Types.JSON where
 import           GHCup.Types
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
-import           GHCup.Utils.Logger             () -- TH is broken shite and needs GHCup.Utils.Logger for linking, although we don't depend on the file.
-                                                   -- This is due to the boot file.

 import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
@@ -44,7 +42,7 @@ import qualified Text.Megaparsec               as MP
 import qualified Text.Megaparsec.Char          as MPC


-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Architecture
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
@@ -56,7 +54,6 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GPGSetting

 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
@@ -319,6 +316,3 @@ 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
-
-deriveToJSON defaultOptions { fieldLabelModifier = kebab } ''Settings
-deriveToJSON defaultOptions { fieldLabelModifier = drop 2 . kebab } ''KeyBindings -- move under key-bindings key
--- a/lib/GHCup/Types/Optics.hs
+++ b/lib/GHCup/Types/Optics.hs
@@ -1,12 +1,4 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE ConstraintKinds       #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE AllowAmbiguousTypes   #-}
-{-# LANGUAGE MultiParamTypeClasses   #-}
-{-# LANGUAGE OverloadedStrings   #-}
+{-# LANGUAGE TemplateHaskell #-}

 {-|
 Module      : GHCup.Types.Optics
@@ -21,12 +13,10 @@ module GHCup.Types.Optics where

 import           GHCup.Types

-import           Control.Monad.Reader
-import           Data.ByteString         ( ByteString )
+import           Data.ByteString                ( ByteString )
 import           Optics
 import           URI.ByteString

-
 makePrisms ''Tool
 makePrisms ''Architecture
 makePrisms ''LinuxDistro
@@ -68,95 +58,3 @@ pathL' = lensVL pathL

 queryL' :: Lens' (URIRef a) Query
 queryL' = lensVL queryL
-
-
-
-    ----------------------
-    --[ Lens utilities ]--
-    ----------------------
-
-
-gets :: forall f a env m . (MonadReader env m, LabelOptic' f A_Lens env a)
-     => m a
-gets = asks (^. labelOptic @f)
-
-
-getAppState :: MonadReader AppState m => m AppState
-getAppState = ask
-
-
-getLeanAppState :: ( MonadReader env m
-                   , LabelOptic' "settings"    A_Lens env Settings
-                   , LabelOptic' "dirs"        A_Lens env Dirs
-                   , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                   , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-                   )
-                => m LeanAppState
-getLeanAppState = do
-  s <- gets @"settings"
-  d <- gets @"dirs"
-  k <- gets @"keyBindings"
-  l <- gets @"loggerConfig"
-  pure (LeanAppState s d k l)
-
-
-getSettings :: ( MonadReader env m
-               , LabelOptic' "settings" A_Lens env Settings
-               )
-            => m Settings
-getSettings = gets @"settings"
-
-
-getDirs :: ( MonadReader env m
-           , LabelOptic' "dirs" A_Lens env Dirs
-           )
-        => m Dirs
-getDirs = gets @"dirs"
-
-
-getLogCleanup :: ( MonadReader env m
-                 , LabelOptic' "logCleanup" A_Lens env (IO ())
-                 )
-              => m (IO ())
-getLogCleanup = gets @"logCleanup"
-
-
-getKeyBindings :: ( MonadReader env m
-                  , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                  )
-               => m KeyBindings
-getKeyBindings = gets @"keyBindings"
-
-
-getGHCupInfo :: ( MonadReader env m
-                , LabelOptic' "ghcupInfo" A_Lens env GHCupInfo
-                )
-             => m GHCupInfo
-getGHCupInfo = gets @"ghcupInfo"
-
-
-getPlatformReq :: ( MonadReader env m
-                  , LabelOptic' "pfreq" A_Lens env PlatformRequest
-                  )
-               => m PlatformRequest
-getPlatformReq = gets @"pfreq"
-
-
-type HasSettings env = (LabelOptic' "settings" A_Lens env Settings)
-type HasDirs env = (LabelOptic' "dirs" A_Lens env Dirs)
-type HasKeyBindings env = (LabelOptic' "keyBindings" A_Lens env KeyBindings)
-type HasGHCupInfo env = (LabelOptic' "ghcupInfo" A_Lens env GHCupInfo)
-type HasPlatformReq env = (LabelOptic' "pfreq" A_Lens env PlatformRequest)
-type HasLog env = (LabelOptic' "loggerConfig" A_Lens env LoggerConfig)
-
-
-getCache :: (MonadReader env m, HasSettings env) => m Bool
-getCache = getSettings <&> cache
-
-
-getDownloader :: (MonadReader env m, HasSettings env) => m Downloader
-getDownloader = getSettings <&> downloader
-
-
-instance LabelOptic "dirs" A_Lens Dirs Dirs Dirs Dirs where
-  labelOptic = lens id (\_ d -> d)
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -35,22 +35,24 @@ import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ

+#if !defined(TAR)
 import           Codec.Archive           hiding ( Directory )
+#endif
+import           Codec.Archive.Zip
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
-import           Control.Monad.IO.Unlift        ( MonadUnliftIO( withRunInIO ) )
 #if defined(IS_WINDOWS)
 import           Data.Bits
 #endif
@@ -58,8 +60,10 @@ import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
 import           Data.List
+import           Data.List.Extra
 import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.Maybe
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           GHC.IO.Exception
@@ -74,10 +78,12 @@ import           System.Win32.Console
 import           System.Win32.File     hiding ( copyFile )
 import           System.Win32.Types
 #endif
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
 import           URI.ByteString

+#if defined(TAR)
+import qualified Codec.Archive.Tar             as Tar
+#endif
 import qualified Codec.Compression.BZip        as BZip
 import qualified Codec.Compression.GZip        as GZip
 import qualified Codec.Compression.Lzma        as Lzma
@@ -86,37 +92,8 @@ import qualified Data.Map.Strict               as Map
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Text.Megaparsec               as MP
-import qualified Data.List.NonEmpty            as NE


-- $setup
-- >>> :set -XOverloadedStrings
-- >>> :set -XDataKinds
-- >>> :set -XTypeApplications
-- >>> :set -XQuasiQuotes
-- >>> import System.Directory
-- >>> import URI.ByteString
-- >>> import qualified Data.Text as T
-- >>> import GHCup.Utils.Prelude
-- >>> import GHCup.Download
-- >>> import GHCup.Version
-- >>> import GHCup.Errors
-- >>> import GHCup.Types
-- >>> import GHCup.Types.Optics
-- >>> import Optics
-- >>> import GHCup.Utils.Version.QQ
-- >>> import qualified Data.Text.Encoding as E
-- >>> import Control.Monad.Reader
-- >>> import Haskus.Utils.Variant.Excepts
-- >>> import Text.PrettyPrint.HughesPJClass ( prettyShow )
-- >>> let lc = LoggerConfig { lcPrintDebug = False, consoleOutter = mempty, fileOutter = mempty, fancyColors = False }
-- >>> dirs' <- getAllDirs
-- >>> let installedVersions = [ ([pver|8.10.7|], Nothing), ([pver|8.10.4|], Nothing), ([pver|8.8.4|], Nothing), ([pver|8.8.3|], Nothing) ]
-- >>> let settings = Settings True False Never Curl False GHCupURL True GPGNone False
-- >>> let leanAppState = LeanAppState settings dirs' defaultKeyBindings lc
-- >>> cwd <- getCurrentDirectory
-- >>> (Right ref) <- pure $ parseURI strictURIParserOptions $ "file://" <> E.encodeUtf8 (T.pack cwd) <> "/data/metadata/" <> (urlBaseName . view pathL' $ ghcupURL)
-- >>> (VRight r) <- (fmap . fmap) _ghcupDownloads $ flip runReaderT leanAppState . runE @'[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError] $ liftE $ getBase ref



@@ -126,79 +103,73 @@ import qualified Data.List.NonEmpty            as NE


 -- | The symlink destination of a ghc tool.
-ghcLinkDestination :: ( MonadReader env m
-                      , HasDirs env
-                      , MonadThrow m, MonadIO m)
+ghcLinkDestination :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                   => FilePath -- ^ the tool, such as 'ghc', 'haddock' etc.
                   -> GHCTargetVersion
                   -> m FilePath
 ghcLinkDestination tool ver = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  ghcd <- ghcupGHCDir ver
  pure (relativeSymlink binDir (ghcd </> "bin" </> tool))


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

  files                         <- liftE $ ghcToolFiles tv
  forM_ files $ \f -> do
    let f_xyz = f <> "-" <> T.unpack (prettyVer _tvVersion) <> exeExt
    let fullF = binDir </> f_xyz
-    lift $ logDebug ("rm -f " <> T.pack fullF)
-    lift $ hideError doesNotExistErrorType $ rmLink fullF
+    lift $ $(logDebug) [i|rm -f #{fullF}|]
+    liftIO $ hideError doesNotExistErrorType $ rmLink fullF


 -- | Removes the set ghc version for the given target, if any.
-rmPlain :: ( MonadReader env m
-           , HasDirs env
-           , HasLog env
+rmPlain :: ( MonadReader AppState m
+           , MonadLogger m
           , MonadThrow m
           , MonadFail m
           , MonadIO m
-           , MonadMask m
           )
        => Maybe Text -- ^ target
        -> Excepts '[NotInstalled] m ()
 rmPlain target = do
-  Dirs {..}  <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
  mtv                           <- lift $ ghcSet target
  forM_ mtv $ \tv -> do
    files <- liftE $ ghcToolFiles tv
    forM_ files $ \f -> do
      let fullF = binDir </> f <> exeExt
-      lift $ logDebug ("rm -f " <> T.pack fullF)
-      lift $ hideError doesNotExistErrorType $ rmLink fullF
+      lift $ $(logDebug) [i|rm -f #{fullF}|]
+      liftIO $ hideError doesNotExistErrorType $ rmLink fullF
    -- old ghcup
    let hdc_file = binDir </> "haddock-ghc" <> exeExt
-    lift $ logDebug ("rm -f " <> T.pack hdc_file)
-    lift $ hideError doesNotExistErrorType $ rmLink hdc_file
+    lift $ $(logDebug) [i|rm -f #{hdc_file}|]
+    liftIO $ hideError doesNotExistErrorType $ rmLink hdc_file


 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorSymlinks :: ( MonadReader env m
-                   , HasDirs env
+rmMajorSymlinks :: ( MonadReader AppState m
                   , MonadIO m
-                   , HasLog env
+                   , MonadLogger m
                   , MonadThrow m
                   , MonadFail m
-                   , MonadMask m
+                   , MonadReader AppState m
                   )
                => GHCTargetVersion
                -> Excepts '[NotInstalled] m ()
 rmMajorSymlinks tv@GHCTargetVersion{..} = do
-  Dirs {..}  <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
  (mj, mi) <- getMajorMinorV _tvVersion
  let v' = intToText mj <> "." <> intToText mi

@@ -206,8 +177,8 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
  forM_ files $ \f -> do
    let f_xy = f <> "-" <> T.unpack v' <> exeExt
    let fullF = binDir </> f_xy
-    lift $ logDebug ("rm -f " <> T.pack fullF)
-    lift $ hideError doesNotExistErrorType $ rmLink fullF
+    lift $ $(logDebug) [i|rm -f #{fullF}|]
+    liftIO $ hideError doesNotExistErrorType $ rmLink fullF



@@ -218,26 +189,26 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do


 -- | Whether the given GHC versin is installed.
-ghcInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcInstalled ver = do
  ghcdir <- ghcupGHCDir ver
  liftIO $ doesDirectoryExist ghcdir


 -- | Whether the given GHC version is installed from source.
-ghcSrcInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcSrcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcSrcInstalled ver = do
  ghcdir <- ghcupGHCDir ver
  liftIO $ doesFileExist (ghcdir </> ghcUpSrcBuiltFile)


 -- | Whether the given GHC version is set as the current.
-ghcSet :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
+ghcSet :: (MonadReader AppState m, MonadThrow m, MonadIO m)
       => Maybe Text   -- ^ the target of the GHC version, if any
                       --  (e.g. armv7-unknown-linux-gnueabihf)
       -> m (Maybe GHCTargetVersion)
 ghcSet mtarget = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
  let ghc = maybe "ghc" (\t -> T.unpack t <> "-ghc") mtarget
  let ghcBin = binDir </> ghc <> exeExt

@@ -268,7 +239,7 @@ ghcSet mtarget = do

 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
-getInstalledGHCs :: (MonadReader env m, HasDirs env, MonadIO m) => m [Either FilePath GHCTargetVersion]
+getInstalledGHCs :: (MonadReader AppState m, MonadIO m) => m [Either FilePath GHCTargetVersion]
 getInstalledGHCs = do
  ghcdir <- ghcupGHCBaseDir
  fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ listDirectory ghcdir
@@ -278,14 +249,10 @@ getInstalledGHCs = do


 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: ( MonadReader env m
-                      , HasDirs env
-                      , MonadIO m
-                      , MonadCatch m
-                      )
+getInstalledCabals :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadCatch m)
                   => m [Either FilePath Version]
 getInstalledCabals = do
-  Dirs {..} <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
@@ -297,16 +264,16 @@ getInstalledCabals = do


 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
  vers <- fmap rights getInstalledCabals
  pure $ elem ver vers


 -- Return the currently set cabal version, if any.
-cabalSet :: (HasLog env, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
  let cabalbin = binDir </> "cabal" <> exeExt

  handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -321,11 +288,7 @@ cabalSet = do
        case linkVersion =<< link of
          Right v -> pure $ Just v
          Left err -> do
-            logWarn $ "Failed to parse cabal symlink target with: "
-              <> T.pack (displayException err)
-              <> ". The symlink "
-              <> T.pack cabalbin
-              <> " needs to point to valid cabal binary, such as 'cabal-3.4.0.0'."
+            $(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
 where
  -- We try to be extra permissive with link destination parsing,
@@ -354,10 +317,10 @@ cabalSet = do

 -- | Get all installed hls, by matching on
 -- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
-getInstalledHLSs :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
+getInstalledHLSs :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                 => m [Either FilePath Version]
 getInstalledHLSs = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended
@@ -374,10 +337,10 @@ getInstalledHLSs = do

 -- | Get all installed stacks, by matching on
 -- @~\/.ghcup\/bin/stack-<\stackver\>@.
-getInstalledStacks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
+getInstalledStacks :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                   => m [Either FilePath Version]
 getInstalledStacks = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended
@@ -392,9 +355,9 @@ getInstalledStacks = do

 -- Return the currently set stack version, if any.
 -- TODO: there's a lot of code duplication here :>
-stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, HasLog env) => m (Maybe Version)
+stackSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m, MonadLogger m) => m (Maybe Version)
 stackSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
  let stackBin = binDir </> "stack" <> exeExt

  handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -409,11 +372,7 @@ stackSet = do
        case linkVersion =<< link of
          Right v -> pure $ Just v
          Left err -> do
-            logWarn $ "Failed to parse stack symlink target with: "
-              <> T.pack (displayException err)
-              <> ". The symlink "
-              <> T.pack stackBin
-              <> " needs to point to valid stack binary, such as 'stack-2.7.1'."
+            $(logWarn) [i|Failed to parse stack symlink target with: "#{err}". The symlink #{stackBin} needs to point to valid stack binary, such as 'stack-2.7.1'.|]
            pure Nothing
 where
  linkVersion :: MonadThrow m => FilePath -> m Version
@@ -436,13 +395,13 @@ stackSet = do
    stripRelativePath = MP.many (MP.try stripPathComponet)

 -- | Whether the given Stack version is installed.
-stackInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+stackInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 stackInstalled ver = do
  vers <- fmap rights getInstalledStacks
  pure $ elem ver vers

 -- | Whether the given HLS version is installed.
-hlsInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 hlsInstalled ver = do
  vers <- fmap rights getInstalledHLSs
  pure $ elem ver vers
@@ -450,9 +409,9 @@ hlsInstalled ver = do


 -- Return the currently set hls version, if any.
-hlsSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+hlsSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 hlsSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
  let hlsBin = binDir </> "haskell-language-server-wrapper" <> exeExt

  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -484,8 +443,7 @@ hlsSet = do


 -- | Return the GHC versions the currently selected HLS supports.
-hlsGHCVersions :: ( MonadReader env m
-                  , HasDirs env
+hlsGHCVersions :: ( MonadReader AppState m
                  , MonadIO m
                  , MonadThrow m
                  , MonadCatch m
@@ -504,15 +462,15 @@ hlsGHCVersions = do
        . splitOn "~"
        )
      bins
-  pure . sortBy (flip compare) . rights . concat . maybeToList $ vers
+  pure . rights . concat . maybeToList $ vers


 -- | Get all server binaries for an hls version, if any.
-hlsServerBinaries :: (MonadReader env m, HasDirs env, MonadIO m)
+hlsServerBinaries :: (MonadReader AppState m, MonadIO m)
                  => Version
                  -> m [FilePath]
 hlsServerBinaries ver = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts
@@ -524,12 +482,12 @@ hlsServerBinaries ver = do


 -- | Get the wrapper binary for an hls version, if any.
-hlsWrapperBinary :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
+hlsWrapperBinary :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                 => Version
                 -> m (Maybe FilePath)
 hlsWrapperBinary ver = do
-  Dirs {..}  <- getDirs
-  wrapper <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+  AppState { dirs = Dirs {..} } <- ask
+  wrapper                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts
      compExtended
@@ -545,7 +503,7 @@ hlsWrapperBinary ver = do


 -- | Get all binaries for an hls version, if any.
-hlsAllBinaries :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m) => Version -> m [FilePath]
+hlsAllBinaries :: (MonadReader AppState m, MonadIO m, MonadThrow m) => Version -> m [FilePath]
 hlsAllBinaries ver = do
  hls     <- hlsServerBinaries ver
  wrapper <- hlsWrapperBinary ver
@@ -553,9 +511,9 @@ hlsAllBinaries ver = do


 -- | Get the active symlinks for hls.
-hlsSymlinks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) => m [FilePath]
+hlsSymlinks :: (MonadReader AppState m, MonadIO m, MonadCatch m) => m [FilePath]
 hlsSymlinks = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended
@@ -588,83 +546,34 @@ matchMajor v' major' minor' = case getMajorMinorV v' of
  Just (x, y) -> x == major' && y == minor'
  Nothing     -> False

-- | Match PVP prefix.
--
-- >>> matchPVPrefix [pver|8.8|] [pver|8.8.4|]
-- True
-- >>> matchPVPrefix [pver|8|] [pver|8.8.4|]
-- True
-- >>> matchPVPrefix [pver|8.10|] [pver|8.8.4|]
-- False
-- >>> matchPVPrefix [pver|8.10|] [pver|8.10.7|]
-- True
-matchPVPrefix :: PVP -> PVP -> Bool
-matchPVPrefix (toL -> prefix) (toL -> full) = and $ zipWith (==) prefix full

-toL :: PVP -> [Int]
-toL (PVP inner) = fmap fromIntegral $ NE.toList inner
-
-
-- | Get the latest installed full GHC version that satisfies the given (possibly partial)
-- PVP version.
-getGHCForPVP :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m)
-             => PVP
-             -> Maybe Text -- ^ the target triple
-             -> m (Maybe GHCTargetVersion)
-getGHCForPVP pvpIn mt = do
+-- | Get the latest installed full GHC version that satisfies X.Y.
+-- This reads `ghcupGHCBaseDir`.
+getGHCForMajor :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+               => Int        -- ^ major version component
+               -> Int        -- ^ minor version component
+               -> Maybe Text -- ^ the target triple
+               -> m (Maybe GHCTargetVersion)
+getGHCForMajor major' minor' mt = do
  ghcs <- rights <$> getInstalledGHCs
-  -- we're permissive here... failed parse just means we have no match anyway
-  let ghcs' = catMaybes $ flip fmap ghcs $ \GHCTargetVersion{..} -> do
-        pvp_ <- versionToPVP _tvVersion
-        pure (pvp_, _tvTarget)

-  getGHCForPVP' pvpIn ghcs' mt
-
-- | Like 'getGHCForPVP', except with explicit input parameter.
--
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8|] installedVersions Nothing
-- "Just 8.10.7"
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8.8|] installedVersions Nothing
-- "Just 8.8.4"
-- >>> fmap prettyShow $ getGHCForPVP' [pver|8.10.4|] installedVersions Nothing
-- "Just 8.10.4"
-getGHCForPVP' :: MonadThrow m
-             => PVP
-             -> [(PVP, Maybe Text)] -- ^ installed GHCs
-             -> Maybe Text          -- ^ the target triple
-             -> m (Maybe GHCTargetVersion)
-getGHCForPVP' pvpIn ghcs' mt = do
-  let mResult = lastMay
-                  . sortBy (\(x, _) (y, _) -> compare x y)
-                  . filter
-                      (\(pvp_, target) ->
-                        target == mt && matchPVPrefix pvp_ pvpIn
-                      )
-                  $ ghcs'
-  forM mResult $ \(pvp_, target) -> do
-    ver' <- pvpToVersion pvp_
-    pure (GHCTargetVersion target ver')
+  pure
+    . lastMay
+    . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
+    . filter
+        (\GHCTargetVersion {..} ->
+          _tvTarget == mt && matchMajor _tvVersion major' minor'
+        )
+    $ ghcs


-- | Get the latest available ghc for the given PVP version, which
-- may only contain parts.
--
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8|] r
-- Just (PVP {_pComponents = 8 :| [10,7]})
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8.8|] r
-- Just (PVP {_pComponents = 8 :| [8,4]})
-- >>> (fmap . fmap) fst $ getLatestToolFor GHC [pver|8.8.4|] r
-- Just (PVP {_pComponents = 8 :| [8,4]})
-getLatestToolFor :: MonadThrow m
-                 => Tool
-                 -> PVP
-                 -> GHCupDownloads
-                 -> m (Maybe (PVP, VersionInfo))
-getLatestToolFor tool pvpIn dls = do
-  let ls = fromMaybe [] $ preview (ix tool % to Map.toDescList) dls
-  let ps = catMaybes $ fmap (\(v, vi) -> (,vi) <$> versionToPVP v) ls
-  pure . headMay . filter (\(v, _) -> matchPVPrefix pvpIn v) $ ps
-
+-- | Get the latest available ghc for X.Y major version.
+getLatestGHCFor :: Int -- ^ major version component
+                -> Int -- ^ minor version component
+                -> GHCupDownloads
+                -> Maybe (Version, VersionInfo)
+getLatestGHCFor major' minor' dls =
+  preview (ix GHC % to Map.toDescList) dls >>= lastMay . filter (\(v, _) -> matchMajor v major' minor')



@@ -676,21 +585,31 @@ getLatestToolFor tool pvpIn dls = do


 -- | Unpack an archive to a temporary directory and return that path.
-unpackToDir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
+unpackToDir :: (MonadLogger m, MonadIO m, MonadThrow m)
            => FilePath       -- ^ destination dir
            -> FilePath       -- ^ archive path
            -> Excepts '[UnknownArchive
+#if !defined(TAR)
                        , ArchiveResult
+#endif
                        ] m ()
 unpackToDir dfp av = do
  let fn = takeFileName av
-  lift $ logInfo $ "Unpacking: " <> T.pack fn <> " to " <> T.pack dfp
+  lift $ $(logInfo) [i|Unpacking: #{fn} to #{dfp}|]

+#if defined(TAR)
+  let untar :: MonadIO m => BL.ByteString -> Excepts '[] m ()
+      untar = liftIO . Tar.unpack dfp . Tar.read
+
+      rf :: MonadIO m => FilePath -> Excepts '[] m BL.ByteString
+      rf = liftIO . BL.readFile
+#else
  let untar :: MonadIO m => BL.ByteString -> Excepts '[ArchiveResult] m ()
      untar = lEM . liftIO . runArchiveM . unpackToDirLazy dfp

      rf :: MonadIO m => FilePath -> Excepts '[ArchiveResult] m BL.ByteString
      rf = liftIO . BL.readFile
+#endif

  -- extract, depending on file extension
  if
@@ -703,23 +622,42 @@ unpackToDir dfp av = do
    | ".tar.bz2" `isSuffixOf` fn ->
      liftE (untar . BZip.decompress =<< rf av)
    | ".tar" `isSuffixOf` fn -> liftE (untar =<< rf av)
-    | ".zip" `isSuffixOf` fn -> liftE (untar =<< rf av)
+    | ".zip" `isSuffixOf` fn ->
+      withArchive av (unpackInto dfp)
    | otherwise -> throwE $ UnknownArchive fn


-getArchiveFiles :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
+getArchiveFiles :: (MonadLogger m, MonadIO m, MonadThrow m)
                => FilePath       -- ^ archive path
                -> Excepts '[UnknownArchive
+#if defined(TAR)
+                            , Tar.FormatError
+#else
                            , ArchiveResult
+#endif
                            ] m [FilePath]
 getArchiveFiles av = do
  let fn = takeFileName av

+#if defined(TAR)
+  let entries :: Monad m => BL.ByteString -> Excepts '[Tar.FormatError] m [FilePath]
+      entries =
+          lE @Tar.FormatError
+          . Tar.foldEntries
+            (\e x -> fmap (Tar.entryPath e :) x)
+            (Right [])
+            (\e -> Left e)
+          . Tar.read
+
+      rf :: MonadIO m => FilePath -> Excepts '[Tar.FormatError] m BL.ByteString
+      rf = liftIO . BL.readFile
+#else
  let entries :: Monad m => BL.ByteString -> Excepts '[ArchiveResult] m [FilePath]
      entries = (fmap . fmap) filepath . lE . readArchiveBSL

      rf :: MonadIO m => FilePath -> Excepts '[ArchiveResult] m BL.ByteString
      rf = liftIO . BL.readFile
+#endif

  -- extract, depending on file extension
  if
@@ -732,11 +670,14 @@ getArchiveFiles av = do
    | ".tar.bz2" `isSuffixOf` fn ->
      liftE (entries . BZip.decompress =<< rf av)
    | ".tar" `isSuffixOf` fn -> liftE (entries =<< rf av)
-    | ".zip" `isSuffixOf` fn -> liftE (entries =<< rf av)
+    | ".zip" `isSuffixOf` fn ->
+      withArchive av $ do
+        entries' <- getEntries
+        pure $ fmap unEntrySelector $ Map.keys entries'
    | otherwise -> throwE $ UnknownArchive fn


-intoSubdir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m, MonadCatch m)
+intoSubdir :: (MonadLogger m, MonadIO m, MonadThrow m, MonadCatch m)
           => FilePath       -- ^ unpacked tar dir
           -> TarDir         -- ^ how to descend
           -> Excepts '[TarDirDoesNotExist] m FilePath
@@ -788,6 +729,19 @@ getLatestBaseVersion av pvpVer =



+    -----------------------
+    --[ AppState Getter ]--
+    -----------------------
+
+
+getCache :: MonadReader AppState m => m Bool
+getCache = ask <&> cache . settings
+
+
+getDownloader :: MonadReader AppState m => m Downloader
+getDownloader = ask <&> downloader . settings
+
+

    -------------
    --[ Other ]--
@@ -800,7 +754,7 @@ getLatestBaseVersion av pvpVer =
 -- Returns unversioned relative files without extension, e.g.:
 --
 --   - @["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]@
-ghcToolFiles :: (MonadReader env m, HasDirs env, MonadThrow m, MonadFail m, MonadIO m)
+ghcToolFiles :: (MonadReader AppState m, MonadThrow m, MonadFail m, MonadIO m)
             => GHCTargetVersion
             -> Excepts '[NotInstalled] m [FilePath]
 ghcToolFiles ver = do
@@ -811,22 +765,49 @@ ghcToolFiles ver = do
  whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
        (throwE (NotInstalled GHC ver))

-  files <- liftIO (listDirectory bindir >>= filterM (doesFileExist . (bindir </>)))
-  pure (getUniqueTools . groupToolFiles . fmap (dropSuffix exeExt) $ files)
+  files    <- liftIO $ listDirectory bindir
+  -- figure out the <ver> suffix, because this might not be `Version` for
+  -- alpha/rc releases, but x.y.a.somedate.

+  ghcIsHadrian    <- liftIO $ isHadrian bindir
+  onlyUnversioned <- case ghcIsHadrian of
+    Right () -> pure id
+    Left (fmap (dropSuffix exeExt) -> [ghc, ghc_ver])
+      | (Just symver) <- stripPrefix (ghc <> "-") ghc_ver
+      , not (null symver) -> pure $ filter (\x -> not $ symver `isInfixOf` x)
+    _ -> fail "Fatal: Could not find internal GHC version"
+
+  pure $ onlyUnversioned $ fmap (dropSuffix exeExt) files
 where
-
-  groupToolFiles :: [FilePath] -> [[(FilePath, String)]]
-  groupToolFiles = groupBy (\(a, _) (b, _) -> a == b) . fmap (splitOnPVP "-")
-
-  getUniqueTools :: [[(FilePath, String)]] -> [String]
-  getUniqueTools = filter (isNotAnyInfix blackListedTools) . nub . fmap fst . filter ((== "") . snd) . concat
-
-  blackListedTools :: [String]
-  blackListedTools = ["haddock-ghc"]
-
-  isNotAnyInfix :: [String] -> String -> Bool
  isNotAnyInfix xs t = foldr (\a b -> not (a `isInfixOf` t) && b) True xs
+    -- GHC is moving some builds to Hadrian for bindists,
+    -- which doesn't create versioned binaries.
+    -- https://gitlab.haskell.org/haskell/ghcup-hs/issues/31
+  isHadrian :: FilePath -- ^ ghcbin path
+            -> IO (Either [String] ()) -- ^ Right for Hadrian
+  isHadrian dir = do
+    -- Non-hadrian has e.g. ["ghc", "ghc-8.10.4"]
+    -- which also requires us to discover the internal version
+    -- to filter the correct tool files.
+    -- We can't use the symlink on windows, so we fall back to some
+    -- more complicated logic.
+    fs <- fmap
+         -- regex over-matches
+         (filter (isNotAnyInfix ["haddock", "ghc-pkg", "ghci"]))
+       $ liftIO $ findFiles
+      dir
+      (makeRegexOpts compExtended
+                     execBlank
+                     -- for cross, this won't be "ghc", but e.g.
+                     -- "armv7-unknown-linux-gnueabihf-ghc"
+                     ([s|^([a-zA-Z0-9_-]*[a-zA-Z0-9_]-)?ghc.*$|] :: ByteString)
+      )
+    if | length fs == 1 -> pure $ Right ()        -- hadrian
+       | length fs == 2 -> pure $ Left
+                              (sortOn length fs)  -- legacy make, result should
+                                                  -- be ["ghc", "ghc-8.10.4"]
+       | otherwise      -> fail "isHadrian failed!"
+


 -- | This file, when residing in @~\/.ghcup\/ghc\/\<ver\>\/@ signals that
@@ -836,12 +817,7 @@ ghcUpSrcBuiltFile = ".ghcup_src_built"


 -- | Calls gmake if it exists in PATH, otherwise make.
-make :: ( MonadThrow m
-        , MonadIO m
-        , MonadReader env m
-        , HasDirs env
-        , HasSettings env
-        )
+make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
     => [String]
     -> Maybe FilePath
     -> m (Either ProcessError ())
@@ -851,7 +827,7 @@ make args workdir = do
  let mymake = if has_gmake then "gmake" else "make"
  execLogged mymake args workdir "ghc-make" Nothing

-makeOut :: (MonadReader env m, HasDirs env, MonadIO m)
+makeOut :: (MonadReader AppState m, MonadIO m)
        => [String]
        -> Maybe FilePath
        -> m CapturedProcess
@@ -864,19 +840,14 @@ makeOut args workdir = do

 -- | Try to apply patches in order. Fails with 'PatchFailed'
 -- on first failure.
-applyPatches :: (MonadReader env m, HasDirs env, HasLog env, MonadIO m)
+applyPatches :: (MonadReader AppState m, MonadLogger m, MonadIO m)
             => FilePath   -- ^ dir containing patches
             -> FilePath   -- ^ dir to apply patches in
             -> Excepts '[PatchFailed] m ()
 applyPatches pdir ddir = do
-  patches <- (fmap . fmap) (pdir </>) $ liftIO $ findFiles
-      pdir
-      (makeRegexOpts compExtended
-                     execBlank
-                     ([s|.+\.(patch|diff)$|] :: ByteString)
-      )
+  patches <- (fmap . fmap) (pdir </>) $ liftIO $ listDirectory pdir
  forM_ (sort patches) $ \patch' -> do
-    lift $ logInfo $ "Applying patch " <> T.pack patch'
+    lift $ $(logInfo) [i|Applying patch #{patch'}|]
    fmap (either (const Nothing) Just)
         (exec
           "patch"
@@ -887,7 +858,7 @@ applyPatches pdir ddir = do


 -- | https://gitlab.haskell.org/ghc/ghc/-/issues/17353
-darwinNotarization :: (MonadReader env m, HasDirs env, MonadIO m)
+darwinNotarization :: (MonadReader AppState m, MonadIO m)
                   => Platform
                   -> FilePath
                   -> m (Either ProcessError ())
@@ -910,31 +881,20 @@ getChangeLog dls tool (Right tag) =
 --
 --   1. the build directory, depending on the KeepDirs setting
 --   2. the install destination, depending on whether the build failed
-runBuildAction :: ( Pretty (V e)
-                  , Show (V e)
-                  , PopVariant BuildFailed e
-                  , ToVariantMaybe BuildFailed e
-                  , MonadReader env m
-                  , HasDirs env
-                  , HasSettings env
-                  , MonadIO m
-                  , MonadMask m
-                  , HasLog env
-                  , MonadUnliftIO m
-                  , MonadFail m
-                  , MonadCatch m
-                  )
-               => FilePath        -- ^ build directory (cleaned up depending on Settings)
+runBuildAction :: (Show (V e), MonadReader AppState m, MonadIO m, MonadMask m)
+               => FilePath          -- ^ build directory (cleaned up depending on Settings)
               -> Maybe FilePath  -- ^ dir to *always* clean up on exception
               -> Excepts e m a
               -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
-  Settings {..} <- lift getSettings
+  AppState { settings = Settings {..} } <- lift ask
  let exAction = do
        forM_ instdir $ \dir ->
-          lift $ hideError doesNotExistErrorType $ recyclePathForcibly dir
+          liftIO $ hideError doesNotExistErrorType $ rmPath dir
        when (keepDirs == Never)
-          $ lift $ rmBDir bdir
+          $ liftIO
+          $ hideError doesNotExistErrorType
+          $ rmPath bdir
  v <-
    flip onException exAction
    $ catchAllE
@@ -943,20 +903,10 @@ runBuildAction bdir instdir action = do
          throwE (BuildFailed bdir es)
        ) action

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


-- | Remove a build directory, ignoring if it doesn't exist and gracefully
-- printing other errors without crashing.
-rmBDir :: (MonadReader env m, HasLog env, MonadUnliftIO m, MonadIO m) => FilePath -> m ()
-rmBDir dir = withRunInIO (\run -> run $
-           liftIO $ handleIO (\e -> run $ logWarn $
-               "Couldn't remove build dir " <> T.pack dir <> ", error was: " <> T.pack (displayException e))
-           $ hideError doesNotExistErrorType
-           $ rmPathForcibly dir)
-
-
 getVersionInfo :: Version
               -> Tool
               -> GHCupDownloads
@@ -1043,13 +993,13 @@ pathIsLink = pathIsSymbolicLink
 #endif


-rmLink :: (MonadReader env m, HasDirs env, MonadIO m, MonadMask m) => FilePath -> m ()
+rmLink :: FilePath -> IO ()
 #if defined(IS_WINDOWS)
 rmLink fp = do
-  hideError doesNotExistErrorType . recycleFile $ fp
-  hideError doesNotExistErrorType . recycleFile $ (dropExtension fp <.> "shim")
+  hideError doesNotExistErrorType . liftIO . rmFile $ fp
+  hideError doesNotExistErrorType . liftIO . rmFile $ (dropExtension fp <.> "shim")
 #else
-rmLink = hideError doesNotExistErrorType . recycleFile
+rmLink = hideError doesNotExistErrorType . liftIO . rmFile
 #endif


@@ -1064,10 +1014,9 @@ rmLink = hideError doesNotExistErrorType . recycleFile
 -- On windows, this requires that 'ensureGlobalTools' was run beforehand.
 createLink :: ( MonadMask m
              , MonadThrow m
-              , HasLog env
+              , MonadLogger m
              , MonadIO m
-              , MonadReader env m
-              , HasDirs env
+              , MonadReader AppState m
              , MonadUnliftIO m
              , MonadFail m
              )
@@ -1076,7 +1025,7 @@ createLink :: ( MonadMask m
           -> m ()
 createLink link exe = do
 #if defined(IS_WINDOWS)
-  dirs <- getDirs
+  AppState { dirs } <- ask
  let shimGen = cacheDir dirs </> "gs.exe"

  let shim = dropExtension exe <.> "shim"
@@ -1086,46 +1035,42 @@ createLink link exe = do
      fullLink = takeDirectory exe </> link
      shimContents = "path = " <> fullLink

-  logDebug $ "rm -f " <> T.pack exe
-  rmLink exe
+  $(logDebug) [i|rm -f #{exe}|]
+  liftIO $ rmLink exe

-  logDebug $ "ln -s " <> T.pack fullLink <> " " <> T.pack exe
+  $(logDebug) [i|ln -s #{fullLink} #{exe}|]
  liftIO $ copyFile shimGen exe
  liftIO $ writeFile shim shimContents
 #else
-  logDebug $ "rm -f " <> T.pack exe
-  hideError doesNotExistErrorType $ recycleFile exe
+  $(logDebug) [i|rm -f #{exe}|]
+  liftIO $ hideError doesNotExistErrorType $ rmFile exe

-  logDebug $ "ln -s " <> T.pack link <> " " <> T.pack exe
+  $(logDebug) [i|ln -s #{link} #{exe}|]
  liftIO $ createFileLink link exe
 #endif


 ensureGlobalTools :: ( MonadMask m
                     , MonadThrow m
-                     , HasLog env
+                     , MonadLogger m
                     , MonadIO m
-                     , MonadReader env m
-                     , HasDirs env
-                     , HasSettings env
-                     , HasGHCupInfo env
+                     , MonadReader AppState m
                     , MonadUnliftIO m
                     , MonadFail m
                     )
-                  => Excepts '[GPGError, DigestError , DownloadFailed, NoDownload] m ()
+                  => Excepts '[DigestError , DownloadFailed, NoDownload] m ()
 ensureGlobalTools = do
 #if defined(IS_WINDOWS)
-  (GHCupInfo _ _ gTools) <- lift getGHCupInfo
-  dirs <- lift getDirs
+  AppState { ghcupInfo = GHCupInfo _ _ gTools, settings, dirs } <- lift ask
  shimDownload <- liftE $ lE @_ @'[NoDownload]
    $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
-  let dl = downloadCached' shimDownload (Just "gs.exe") Nothing
-  void $ (\(DigestError _ _ _) -> do
-      lift $ logWarn "Digest doesn't match, redownloading gs.exe..."
-      lift $ logDebug ("rm -f " <> T.pack (cacheDir dirs </> "gs.exe"))
-      lift $ hideError doesNotExistErrorType $ recycleFile (cacheDir dirs </> "gs.exe")
-      liftE @'[GPGError, DigestError , DownloadFailed] $ dl
-    ) `catchE` (liftE @'[GPGError, DigestError , DownloadFailed] dl)
+  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 ()
@@ -1134,24 +1079,17 @@ ensureGlobalTools = do

 -- | Ensure ghcup directory structure exists.
 ensureDirectories :: Dirs -> IO ()
-ensureDirectories (Dirs baseDir binDir cacheDir logsDir confDir trashDir) = do
+ensureDirectories dirs = do
+  let Dirs
+        { baseDir
+        , binDir
+        , cacheDir
+        , logsDir
+        , confDir
+        } = dirs
  createDirRecursive' baseDir
-  createDirRecursive' (baseDir </> "ghc")
  createDirRecursive' binDir
  createDirRecursive' cacheDir
  createDirRecursive' logsDir
  createDirRecursive' confDir
-  createDirRecursive' trashDir
  pure ()
-
-
-- | For ghc without arch triple, this is:
--
--    - ghc-<ver> (e.g. ghc-8.10.4)
--
-- For ghc with arch triple:
--
--    - <triple>-ghc-<ver> (e.g. arm-linux-gnueabihf-ghc-8.10.4)
-ghcBinaryName :: GHCTargetVersion -> String
-ghcBinaryName (GHCTargetVersion (Just t) v') = T.unpack (t <> "-ghc-" <> prettyVer v' <> T.pack exeExt)
-ghcBinaryName (GHCTargetVersion Nothing  v') = T.unpack ("ghc-" <> prettyVer v' <> T.pack exeExt)
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -2,7 +2,9 @@
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ViewPatterns          #-}
+{-# LANGUAGE TemplateHaskell       #-}

 {-|
 Module      : GHCup.Utils.Dirs
@@ -14,7 +16,7 @@ Stability   : experimental
 Portability : portable
 -}
 module GHCup.Utils.Dirs
-  ( getAllDirs
+  ( getDirs
  , ghcupBaseDir
  , ghcupConfigFile
  , ghcupCacheDir
@@ -28,7 +30,6 @@ module GHCup.Utils.Dirs
 #if !defined(IS_WINDOWS)
  , useXDG
 #endif
-  , cleanupTrash
  )
 where

@@ -36,22 +37,24 @@ where
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
-import           GHCup.Types.Optics
 import           GHCup.Utils.MegaParsec
-import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude

 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Unlift
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource hiding (throwM)
 import           Data.Bifunctor
 import           Data.Maybe
+import           Data.String.Interpolate
 import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
+#if !defined(IS_WINDOWS)
 import           System.Directory                                                
+#endif
 import           System.DiskSpace                                                
 import           System.Environment
 import           System.FilePath
@@ -59,7 +62,7 @@ import           System.IO.Temp

 import qualified Data.ByteString               as BS
 import qualified Data.Text                     as T
-import qualified Data.YAML.Aeson               as Y
+import qualified Data.Yaml                     as Y
 import qualified Text.Megaparsec               as MP
 import Control.Concurrent (threadDelay)

@@ -187,21 +190,13 @@ ghcupLogsDir = do
 #endif


-- | '~/.ghcup/trash'.
-- Mainly used on windows to improve file removal operations
-ghcupRecycleDir :: IO FilePath
-ghcupRecycleDir = ghcupBaseDir <&> (</> "trash")
-
-
-
-getAllDirs :: IO Dirs
-getAllDirs = do
-  baseDir    <- ghcupBaseDir
-  binDir     <- ghcupBinDir
-  cacheDir   <- ghcupCacheDir
-  logsDir    <- ghcupLogsDir
-  confDir    <- ghcupConfigDir
-  recycleDir <- ghcupRecycleDir
+getDirs :: IO Dirs
+getDirs = do
+  baseDir  <- ghcupBaseDir
+  binDir   <- ghcupBinDir
+  cacheDir <- ghcupCacheDir
+  logsDir  <- ghcupLogsDir
+  confDir  <- ghcupConfigDir
  pure Dirs { .. }


@@ -222,7 +217,7 @@ ghcupConfigFile = do
  contents <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> BS.readFile filepath
  case contents of
      Nothing -> pure defaultUserSettings
-      Just contents' -> lE' JSONDecodeError . first snd . Y.decode1Strict $ contents'
+      Just contents' -> lE' JSONDecodeError . first show . Y.decodeEither' $ contents'


    -------------------------
@@ -231,9 +226,9 @@ ghcupConfigFile = do


 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader env m, HasDirs env) => m FilePath
+ghcupGHCBaseDir :: (MonadReader AppState m) => m FilePath
 ghcupGHCBaseDir = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  pure (baseDir </> "ghc")


@@ -241,7 +236,7 @@ ghcupGHCBaseDir = do
 -- The dir may be of the form
 --   * armv7-unknown-linux-gnueabihf-8.8.3
 --   * 8.8.4
-ghcupGHCDir :: (MonadReader env m, HasDirs env, MonadThrow m)
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
            => GHCTargetVersion
            -> m FilePath
 ghcupGHCDir ver = do
@@ -256,61 +251,29 @@ parseGHCupGHCDir (T.pack -> fp) =
  throwEither $ MP.parse ghcTargetVerP "" fp


-mkGhcupTmpDir :: ( MonadReader env m
-                 , HasDirs env
-                 , MonadUnliftIO m
-                 , HasLog env
-                 , MonadCatch m
-                 , MonadThrow m
-                 , MonadMask m
-                 , MonadIO m)
-              => m FilePath
+mkGhcupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadThrow m, MonadIO m) => m FilePath
 mkGhcupTmpDir = do
  tmpdir <- liftIO getCanonicalTemporaryDirectory

  let minSpace = 5000 -- a rough guess, aight?
  space <- handleIO (\_ -> pure Nothing) $ fmap Just $ liftIO $ getAvailSpace tmpdir
  when (maybe False (toBytes minSpace >) space) $ do
-    logWarn ("Possibly insufficient disk space on "
-      <> T.pack tmpdir
-      <> ". At least "
-      <> T.pack (show minSpace)
-      <> " MB are recommended, but only "
-      <> toMB (fromJust space)
-      <> " are free. Consider freeing up disk space or setting TMPDIR env variable.")
-    logWarn
+    $(logWarn) [i|Possibly insufficient disk space on #{tmpdir}. At least #{minSpace} MB are recommended, but only #{toMB (fromJust space)} are free. Consider freeing up disk space or setting TMPDIR env variable.|]
+    $(logWarn)
      "...waiting for 10 seconds before continuing anyway, you can still abort..."
    liftIO $ threadDelay 10000000 -- give the user a sec to intervene

  liftIO $ createTempDirectory tmpdir "ghcup"
 where
  toBytes mb = mb * 1024 * 1024
-  toMB b = T.pack $ show (truncate' (fromIntegral b / (1024 * 1024) :: Double) 2)
+  toMB b = show (truncate' (fromIntegral b / (1024 * 1024) :: Double) 2)
  truncate' :: Double -> Int -> Double
  truncate' x n = fromIntegral (floor (x * t) :: Integer) / t
      where t = 10^n


-withGHCupTmpDir :: ( MonadReader env m
-                   , HasDirs env
-                   , HasLog env
-                   , HasSettings env
-                   , MonadUnliftIO m
-                   , MonadCatch m
-                   , MonadResource m
-                   , MonadThrow m
-                   , MonadMask m
-                   , MonadIO m)
-                => m FilePath
-withGHCupTmpDir = snd <$> withRunInIO (\run ->
-  run
-    $ allocate
-        (run mkGhcupTmpDir)
-        (\fp ->
-            handleIO (\e -> run
-                $ logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e)))
-            . rmPathForcibly
-            $ fp))
+withGHCupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadResource m, MonadThrow m, MonadIO m) => m FilePath
+withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir) rmPath)



@@ -338,22 +301,3 @@ relativeSymlink p1 p2 =
        <> joinPath ([pathSeparator] : drop (length common) d2)


-cleanupTrash :: ( MonadIO m
-                , MonadMask m
-                , MonadReader env m
-                , HasLog env
-                , HasDirs env
-                , HasSettings env
-                )
-             => m ()
-cleanupTrash = do
-  Dirs { recycleDir } <- getDirs
-  contents <- liftIO $ listDirectory recycleDir
-  if null contents
-  then pure ()
-  else do
-    logWarn ("Removing leftover files in " <> T.pack recycleDir)
-    forM_ contents (\fp -> handleIO (\e ->
-        logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e))
-      ) $ liftIO $ removePathForcibly (recycleDir </> fp))
-
--- a/lib/GHCup/Utils/File/Common.hs
+++ b/lib/GHCup/Utils/File/Common.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE TemplateHaskell   #-}
@@ -7,10 +8,10 @@ module GHCup.Utils.File.Common where

 import           GHCup.Utils.Prelude

+import           Control.Monad.Extra
 import           Control.Monad.Reader
 import           Data.Maybe
-import           Data.Text               ( Text )
-import           Data.Void
+import           Data.String.Interpolate
 import           GHC.IO.Exception
 import           Optics                  hiding ((<|), (|>))
 import           System.Directory
@@ -18,9 +19,7 @@ import           System.FilePath
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix

-import qualified Data.Text                     as T
 import qualified Data.ByteString.Lazy          as BL
-import qualified Text.Megaparsec               as MP



@@ -32,13 +31,13 @@ data ProcessError = NonZeroExit Int FilePath [String]

 instance Pretty ProcessError where
  pPrint (NonZeroExit e exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "failed with exit code" <+> text (show e <> ".")
+    text [i|Process "#{exe}" with arguments #{args} failed with exit code #{e}.|]
  pPrint (PTerminated exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "terminated."
+    text [i|Process "#{exe}" with arguments #{args} terminated.|]
  pPrint (PStopped exe args) =
-    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "stopped."
+    text [i|Process "#{exe}" with arguments #{args} stopped.|]
  pPrint (NoSuchPid exe args) =
-    text "Could not find PID for process running " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text "."
+    text [i|Could not find PID for process running "#{exe}" with arguments #{args}.|]

 data CapturedProcess = CapturedProcess
  { _exitCode :: ExitCode
@@ -105,11 +104,3 @@ findFiles path regex = do
  contents <- listDirectory path
  pure $ filter (match regex) contents

-findFiles' :: FilePath -> MP.Parsec Void Text a -> IO [FilePath]
-findFiles' path parser = do
-  contents <- listDirectory path
-  pure $ filter (\fp -> either (const False) (const True) $ MP.parse parser "" (T.pack fp)) contents
-
-
-checkFileAlreadyExists :: (MonadIO m) => FilePath -> m Bool
-checkFileAlreadyExists fp = liftIO $ doesFileExist fp
--- a/lib/GHCup/Utils/File/Common.hs-boot
+++ b/lib/GHCup/Utils/File/Common.hs-boot
@@ -1,5 +0,0 @@
-module GHCup.Utils.File.Common where
-
-import           Text.Regex.Posix
-
-findFiles :: FilePath -> Regex -> IO [FilePath]
--- a/lib/GHCup/Utils/File/Posix.hs
+++ b/lib/GHCup/Utils/File/Posix.hs
@@ -1,5 +1,8 @@
+{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE ViewPatterns      #-}

 {-|
 Module      : GHCup.Utils.File.Posix
@@ -17,25 +20,26 @@ module GHCup.Utils.File.Posix where

 import           GHCup.Utils.File.Common
 import           GHCup.Utils.Prelude
-import           GHCup.Utils.Logger
 import           GHCup.Types
-import           GHCup.Types.Optics

 import           Control.Concurrent
 import           Control.Concurrent.Async
 import           Control.Exception              ( evaluate )
 import           Control.Exception.Safe
 import           Control.Monad
+import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.State.Strict
 import           Data.ByteString                ( ByteString )
 import           Data.Foldable
 import           Data.IORef
 import           Data.Sequence                  ( Seq, (|>) )
+import           Data.String.Interpolate
 import           Data.List
 import           Data.Word8
 import           GHC.IO.Exception
-import           System.Console.Terminal.Common
+import           System.Console.Pretty   hiding ( Pretty )
+import           System.Console.Regions
 import           System.IO.Error
 import           System.FilePath
 import           System.Directory
@@ -51,7 +55,6 @@ import qualified Data.Sequence                 as Sq
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified System.Posix.Process          as SPP
-import qualified System.Console.Terminal.Posix as TP
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Lazy          as BL
 import qualified "unix-bytestring" System.Posix.IO.ByteString
@@ -71,11 +74,7 @@ executeOut path args chdir = liftIO $ captureOutStreams $ do
  SPP.executeFile path True args Nothing


-execLogged :: ( MonadReader env m
-              , HasSettings env
-              , HasDirs env
-              , MonadIO m
-              , MonadThrow m)
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
           => FilePath         -- ^ thing to execute
           -> [String]         -- ^ args for the thing
           -> Maybe FilePath   -- ^ optionally chdir into this
@@ -83,14 +82,13 @@ execLogged :: ( MonadReader env m
           -> Maybe [(String, String)] -- ^ optional environment
           -> m (Either ProcessError ())
 execLogged exe args chdir lfile env = do
-  Settings {..} <- getSettings
-  Dirs {..} <- getDirs
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
  let logfile = logsDir </> lfile <> ".log"
  liftIO $ bracket (openFd logfile WriteOnly (Just newFilePerms) defaultFileFlags{ append = True })
                   closeFd
-                   (action verbose noColor)
+                   (action verbose)
 where
-  action verbose no_color fd = do
+  action verbose fd = do
    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
      -- start the thread that logs to stdout
      pState <- newEmptyMVar
@@ -101,7 +99,7 @@ execLogged exe args chdir lfile env = do
        $ EX.finally
            (if verbose
              then tee fd stdoutRead
-              else printToRegion fd stdoutRead 6 pState no_color
+              else printToRegion fd stdoutRead 6 pState
            )
            (putMVar done ())

@@ -128,7 +126,7 @@ execLogged exe args chdir lfile env = do
      pure e

  tee :: Fd -> Fd -> IO ()
-  tee fileFd = readTilEOF lineAction
+  tee fileFd fdIn = readTilEOF lineAction fdIn

   where
    lineAction :: ByteString -> IO ()
@@ -138,57 +136,46 @@ execLogged exe args chdir lfile env = do

  -- Reads fdIn and logs the output in a continous scrolling area
  -- of 'size' terminal lines. Also writes to a log file.
-  printToRegion :: Fd -> Fd -> Int -> MVar Bool -> Bool -> IO ()
-  printToRegion fileFd fdIn size pState no_color = do
-    -- init region
-    forM_ [1..size] $ \_ -> BS.putStr "\n"
-
-    void $ flip runStateT mempty
-      $ do
-        handle
-          (\(ex :: SomeException) -> do
-            ps <- liftIO $ takeMVar pState
-            when ps (liftIO $ BS.putStr (pos1 <> moveLineUp size <> clearScreen))
-            throw ex
-          ) $ readTilEOF lineAction fdIn
+  printToRegion :: Fd -> Fd -> Int -> MVar Bool -> IO ()
+  printToRegion fileFd fdIn size pState = do
+    void $ displayConsoleRegions $ do
+      rs <-
+        liftIO
+        . fmap Sq.fromList
+        . sequence
+        . replicate size
+        . openConsoleRegion
+        $ Linear
+      flip runStateT mempty
+        $ handle
+            (\(ex :: SomeException) -> do
+              ps <- liftIO $ takeMVar pState
+              when ps (forM_ rs (liftIO . closeConsoleRegion))
+              throw ex
+            )
+        $ readTilEOF (lineAction rs) fdIn

   where
-    clearScreen :: ByteString
-    clearScreen = "\x1b[0J"
-    clearLine :: ByteString
-    clearLine = "\x1b[2K"
-    moveLineUp :: Int -> ByteString
-    moveLineUp n = "\x1b[" <> E.encodeUtf8 (T.pack (show n)) <> "A"
-    moveLineDown :: Int -> ByteString
-    moveLineDown n = "\x1b[" <> E.encodeUtf8 (T.pack (show n)) <> "B"
-    pos1 :: ByteString
-    pos1 = "\r"
-    overwriteNthLine :: Int -> ByteString -> ByteString
-    overwriteNthLine n str = pos1 <> moveLineUp n <> clearLine <> str <> moveLineDown n <> pos1
-
-    blue :: ByteString -> ByteString
-    blue bs 
-      | no_color = bs
-      | otherwise = "\x1b[0;34m" <> bs <> "\x1b[0m"
-
    -- action to perform line by line
+    -- TODO: do this with vty for efficiency
    lineAction :: (MonadMask m, MonadIO m)
-               => ByteString
+               => Seq ConsoleRegion
+               -> ByteString
               -> StateT (Seq ByteString) m ()
-    lineAction = \bs' -> do
+    lineAction rs = \bs' -> do
      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
      modify (swapRegs bs')
-      liftIO TP.size >>= \case
-        Nothing -> pure ()
-        Just (Window _ w) -> do
-          regs <- get
-          liftIO $ forM_ (Sq.zip regs (Sq.fromList [0..(Sq.length regs - 1)])) $ \(bs, i) -> do
-              BS.putStr
-              . overwriteNthLine (size - i)
-              . trim w
-              . blue
-              . (\b -> "[ " <> E.encodeUtf8 (T.pack lfile) <> " ] " <> b)
-              $ bs
+      regs <- get
+      liftIO $ forM_ (Sq.zip regs rs) $ \(bs, r) -> setConsoleRegion r $ do
+        w <- consoleWidth
+        return
+          . T.pack
+          . color Blue
+          . T.unpack
+          . decUTF8Safe
+          . trim w
+          . (\b -> "[ " <> E.encodeUtf8 (T.pack lfile) <> " ] " <> b)
+          $ bs

    swapRegs :: a -> Seq a -> Seq a
    swapRegs bs = \regs -> if
@@ -358,7 +345,7 @@ toProcessError exe args mps = case mps of



-chmod_755 :: (MonadReader env m, HasLog env, MonadIO m) => FilePath -> m ()
+chmod_755 :: (MonadLogger m, MonadIO m) => FilePath -> m ()
 chmod_755 fp = do
  let exe_mode =
          nullFileMode
@@ -369,7 +356,7 @@ chmod_755 fp = do
            `unionFileModes` groupReadMode
            `unionFileModes` otherExecuteMode
            `unionFileModes` otherReadMode
-  logDebug ("chmod 755 " <> T.pack fp)
+  $(logDebug) [i|chmod 755 #{fp}|]
  liftIO $ setFileMode fp exe_mode


--- a/lib/GHCup/Utils/File/Windows.hs
+++ b/lib/GHCup/Utils/File/Windows.hs
@@ -19,7 +19,6 @@ import {-# SOURCE #-} GHCup.Utils ( getLinkTarget, pathIsLink )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File.Common
 import           GHCup.Types
-import           GHCup.Types.Optics

 import           Control.Concurrent
 import           Control.DeepSeq
@@ -147,11 +146,7 @@ executeOut path args chdir = do
  pure $ CapturedProcess exit out err


-execLogged :: ( MonadReader env m
-              , HasDirs env
-              , HasSettings env
-              , MonadIO m
-              , MonadThrow m)
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
           => FilePath         -- ^ thing to execute
           -> [String]         -- ^ args for the thing
           -> Maybe FilePath   -- ^ optionally chdir into this
@@ -159,7 +154,7 @@ execLogged :: ( MonadReader env m
           -> Maybe [(String, String)] -- ^ optional environment
           -> m (Either ProcessError ())
 execLogged exe args chdir lfile env = do
-  Dirs {..} <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
  let stdoutLogfile = logsDir </> lfile <> ".stdout.log"
      stderrLogfile = logsDir </> lfile <> ".stderr.log"
  cp <- createProcessWithMingwPath ((proc exe args)
@@ -209,20 +204,6 @@ exec exe args chdir env = do
  pure $ toProcessError exe args exit_code


-- | Thin wrapper around `executeFile`.
-execShell :: MonadIO m
-          => FilePath       -- ^ thing to execute
-          -> [FilePath]     -- ^ args for the thing
-          -> Maybe FilePath   -- ^ optionally chdir into this
-          -> Maybe [(String, String)] -- ^ optional environment
-          -> m (Either ProcessError ())
-execShell exe args chdir env = do
-  let cmd = exe <> " " <> concatMap (' ':) args
-  cp <- createProcessWithMingwPath ((shell cmd) { cwd = chdir, env = env })
-  exit_code <- liftIO $ withCreateProcess cp $ \_ _ _ p -> waitForProcess p
-  pure $ toProcessError cmd [] exit_code
-
-
 chmod_755 :: MonadIO m => FilePath -> m ()
 chmod_755 fp =
  let perm = setOwnerWritable True emptyPermissions
--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE QuasiQuotes      #-}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE OverloadedStrings   #-}

 {-|
 Module      : GHCup.Utils.Logger
@@ -16,17 +14,12 @@ Here we define our main logger.
 -}
 module GHCup.Utils.Logger where

-import           GHCup.Types
-import           GHCup.Types.Optics
-import {-# SOURCE #-} GHCup.Utils.File.Common
+import           GHCup.Utils.File
 import           GHCup.Utils.String.QQ

-import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Reader
-import           Data.Text               ( Text )
-import           Optics
+import           Control.Monad.Logger
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -35,97 +28,54 @@ import           Text.Regex.Posix

 import qualified Data.ByteString               as B
 import GHCup.Utils.Prelude
-import qualified Data.Text                     as T
-
-logInfo :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-logInfo = logInternal Info
-
-logWarn :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-logWarn = logInternal Warn
-
-logDebug :: ( MonadReader env m
-            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-            , MonadIO m
-            )
-         => Text
-         -> m ()
-logDebug = logInternal Debug
-
-logError :: ( MonadReader env m
-            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-            , MonadIO m
-            )
-         => Text
-         -> m ()
-logError = logInternal Error


-logInternal :: ( MonadReader env m
-               , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-               , MonadIO m
-               ) => LogLevel
-                 -> Text
-                 -> m ()
-logInternal logLevel msg = do
-  LoggerConfig {..} <- gets @"loggerConfig"
-  let color' c = if fancyColors then color c else id
-  let style' = case logLevel of
-        Debug   -> style Bold . color' Blue
-        Info    -> style Bold . color' Green
-        Warn    -> style Bold . color' Yellow
-        Error   -> style Bold . color' Red
-  let l = case logLevel of
-        Debug   -> style' "[ Debug ]"
-        Info    -> style' "[ Info  ]"
-        Warn    -> style' "[ Warn  ]"
-        Error   -> style' "[ Error ]"
-  let strs = T.split (== '\n') msg
-  let out = case strs of
-              [] -> T.empty
-              (x:xs) -> 
-                  foldr (\a b -> a <> "\n" <> b) mempty
-                . ((l <> " " <> x) :)
-                . fmap (\line' -> style' "[ ...   ] " <> line' )
-                $ xs
-
-  when (lcPrintDebug || (not lcPrintDebug && (logLevel /= Debug)))
-    $ liftIO $ consoleOutter out
-
-  -- raw output
-  let lr = case logLevel of
-        Debug   -> "Debug:"
-        Info    -> "Info:"
-        Warn    -> "Warn:"
-        Error   -> "Error:"
-  let outr = lr <> " " <> msg <> "\n"
-  liftIO $ fileOutter outr
+data LoggerConfig = LoggerConfig
+  { lcPrintDebug :: Bool                  -- ^ whether to print debug in colorOutter
+  , colorOutter  :: B.ByteString -> IO () -- ^ how to write the color output
+  , rawOutter    :: B.ByteString -> IO () -- ^ how to write the full raw output
+  }


-initGHCupFileLogging :: ( MonadReader env m
-                        , HasDirs env
-                        , MonadIO m
-                        , MonadMask m
-                        ) => m FilePath
-initGHCupFileLogging = do
-  Dirs { logsDir } <- getDirs
+myLoggerT :: LoggerConfig -> LoggingT m a -> m a
+myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
+ where
+  mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
+  mylogger _ _ level str' = do
+    -- color output
+    let l = case level of
+          LevelDebug   -> toLogStr (style Bold $ color Blue "[ Debug ]")
+          LevelInfo    -> toLogStr (style Bold $ color Green "[ Info  ]")
+          LevelWarn    -> toLogStr (style Bold $ color Yellow "[ Warn  ]")
+          LevelError   -> toLogStr (style Bold $ color Red "[ Error ]")
+          LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
+    let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
+
+    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
+      $ colorOutter out
+
+    -- raw output
+    let lr = case level of
+          LevelDebug   -> toLogStr "Debug: "
+          LevelInfo    -> toLogStr "Info:"
+          LevelWarn    -> toLogStr "Warn:"
+          LevelError   -> toLogStr "Error:"
+          LevelOther t -> toLogStr t <> toLogStr ":"
+    let outr = fromLogStr (lr <> toLogStr " " <> str' <> toLogStr "\n")
+    rawOutter outr
+
+
+initGHCupFileLogging :: (MonadIO m) => FilePath -> m FilePath
+initGHCupFileLogging logsDir = do
  let logfile = logsDir </> "ghcup.log"
-  logFiles <- liftIO $ findFiles
-    logsDir
-    (makeRegexOpts compExtended
-                   execBlank
-                   ([s|^.*\.log$|] :: B.ByteString)
-    )
-  forM_ logFiles $ hideError doesNotExistErrorType . recycleFile . (logsDir </>)
+  liftIO $ do
+    logFiles <- findFiles
+      logsDir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^.*\.log$|] :: B.ByteString)
+      )
+    forM_ logFiles $ hideError doesNotExistErrorType . rmFile . (logsDir </>)

-  liftIO $ writeFile logfile ""
-  pure logfile
+    writeFile logfile ""
+    pure logfile
--- a/lib/GHCup/Utils/Logger.hs-boot
+++ b/lib/GHCup/Utils/Logger.hs-boot
@@ -1,21 +0,0 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE QuasiQuotes      #-}
-{-# LANGUAGE DataKinds        #-}
-{-# LANGUAGE OverloadedStrings   #-}
-
-module GHCup.Utils.Logger where
-
-import           GHCup.Types
-
-import           Control.Monad.IO.Class
-import           Control.Monad.Reader
-import           Data.Text               ( Text )
-import           Optics
-
-logWarn :: ( MonadReader env m
-           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-           , MonadIO m
-           )
-        => Text
-        -> m ()
-
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@@ -19,35 +19,22 @@ GHCup specific prelude. Lots of Excepts functionality.
 -}
 module GHCup.Utils.Prelude where

-#if defined(IS_WINDOWS)
-import           GHCup.Types
-#endif
-import           GHCup.Errors
-import           GHCup.Types.Optics
-import {-# SOURCE #-} GHCup.Utils.Logger
-
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Reader
+import           Control.Monad.Trans.Class      ( lift )
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
-import           Data.List                      ( nub, intercalate, stripPrefix, isPrefixOf )
-import           Data.Maybe
+import           Data.List                      ( nub )
 import           Data.Foldable
-import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Data.Word8                  hiding ( isDigit )
+import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
-import           Text.PrettyPrint.HughesPJClass ( prettyShow, Pretty )
 import           System.IO.Error
-#if defined(IS_WINDOWS)
-import           System.IO.Temp
-#endif
 import           System.IO.Unsafe
 import           System.Directory
 import           System.FilePath
@@ -60,8 +47,6 @@ import           GHC.IO.Exception
 import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
-import qualified Data.List.Split               as Split
-import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
@@ -69,20 +54,8 @@ import qualified Data.Text.Lazy                as TL
 import qualified Data.Text.Lazy.Builder        as B
 import qualified Data.Text.Lazy.Builder.Int    as B
 import qualified Data.Text.Lazy.Encoding       as TLE
-#if defined(IS_WINDOWS)
-import qualified System.Win32.File             as Win32
-#endif


-- $setup
-- >>> import Data.ByteString.Internal (c2w, w2c)
-- >>> import Test.QuickCheck
-- >>> import Data.Word8
-- >>> import qualified Data.Text as T
-- >>> import qualified Data.Char as C
-- >>> import Data.List
-- >>> instance Arbitrary T.Text where arbitrary = T.pack <$> arbitrary
-

 fS :: IsString a => String -> a
 fS = fromString
@@ -177,14 +150,6 @@ lEM' :: forall e' e es a m
     -> Excepts es m a
 lEM' f em = lift em >>= lE . first f

-- for some obscure reason... this won't type-check if we move it to a different module
-catchWarn :: forall es m env . ( Pretty (V es)
-                             , MonadReader env m
-                             , HasLog env
-                             , MonadIO m
-                             , Monad m) => Excepts es m () -> Excepts '[] m ()
-catchWarn = catchAllE @_ @es (\v -> lift $ logWarn (T.pack . prettyShow $ v))
-
 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight

@@ -299,28 +264,12 @@ removeLensFieldLabel str' =
  maybe str' T.unpack . T.stripPrefix (T.pack "_") . T.pack $ str'


-pvpToVersion :: MonadThrow m => PVP -> m Version
+pvpToVersion :: PVP -> Version
 pvpToVersion =
-  either (\_ -> throwM $ ParseError "Couldn't convert PVP to Version") pure . version . prettyPVP
+  either (\_ -> error "Couldn't convert PVP to Version") id
+    . version
+    . prettyPVP

-versionToPVP :: MonadThrow m => Version -> m PVP
-versionToPVP v = either (\_ -> alternative v) pure . pvp . prettyVer $ v
- where
-  alternative :: MonadThrow m => Version -> m PVP
-  alternative v' = case NE.takeWhile isDigit (_vChunks v') of
-    [] -> throwM $ ParseError "Couldn't convert Version to PVP"
-    xs -> pure $ pvpFromList (unsafeDigit <$> xs)
-
-  isDigit :: VChunk -> Bool
-  isDigit (Digits _ :| []) = True
-  isDigit _                = False
-
-  unsafeDigit :: VChunk -> Int
-  unsafeDigit (Digits x :| []) = fromIntegral x
-  unsafeDigit _ = error "unsafeDigit: wrong input"
-
-pvpFromList :: [Int] -> PVP
-pvpFromList = PVP . NE.fromList . fmap fromIntegral

 -- | Safe 'decodeUtf8With'. Replaces an invalid input byte with
 -- the Unicode replacement character U+FFFD.
@@ -363,16 +312,17 @@ createDirRecursive' p =
 -- | Recursively copy the contents of one directory to another path.
 --
 -- This is a rip-off of Cabal library.
-copyDirectoryRecursive :: FilePath -> FilePath -> (FilePath -> FilePath -> IO ()) -> IO ()
-copyDirectoryRecursive srcDir destDir doCopy = do
+copyDirectoryRecursive :: FilePath -> FilePath -> IO ()
+copyDirectoryRecursive srcDir destDir = do
  srcFiles <- getDirectoryContentsRecursive srcDir
-  copyFilesWith destDir [ (srcDir, f)
-                          | f <- srcFiles ]
+  copyFilesWith copyFile destDir [ (srcDir, f)
+                                   | f <- srcFiles ]
  where
    -- | Common implementation of 'copyFiles', 'installOrdinaryFiles',
    -- 'installExecutableFiles' and 'installMaybeExecutableFiles'.
-    copyFilesWith :: FilePath -> [(FilePath, FilePath)] -> IO ()
-    copyFilesWith targetDir srcFiles = do
+    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
@@ -417,125 +367,43 @@ getDirectoryContentsRecursive topdir = recurseDirectories [""]
        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
-recyclePathForcibly :: ( MonadIO m
-                       , MonadReader env m
-                       , HasDirs env
-                       , MonadMask m
-                       )
-                    => FilePath
-                    -> m ()
-recyclePathForcibly fp = do
+rmPath :: (MonadIO m, MonadMask m)
+      => FilePath
+      -> m ()
+rmPath fp =
 #if defined(IS_WINDOWS)
-  Dirs { recycleDir } <- getDirs
-  tmp <- liftIO $ createTempDirectory recycleDir "recyclePathForcibly"
-  let dest = tmp </> takeFileName fp
-  liftIO (Win32.moveFileEx fp (Just dest) 0)
-      `catch`
-      (\e -> if isPermissionError e {- EXDEV on windows -} then recover (liftIO $ removePathForcibly fp) else throwIO e)
-      `finally`
-        (liftIO $ handleIO (\_ -> pure ()) $ removePathForcibly tmp)
+  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 $ removePathForcibly fp
-#endif
-
-
-rmPathForcibly :: ( MonadIO m
-                  , MonadMask m
-                  )
-               => FilePath
-               -> m ()
-rmPathForcibly fp =
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removePathForcibly fp)
-#else
-  liftIO $ removePathForcibly fp
-#endif
-
-
-rmDirectory :: (MonadIO m, MonadMask m)
-            => FilePath
-            -> m ()
-rmDirectory fp =
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removeDirectory fp)
-#else
-  liftIO $ removeDirectory fp
+  liftIO $ removeDirectoryRecursive fp
 #endif


 -- https://www.sqlite.org/src/info/89f1848d7f
 -- https://github.com/haskell/directory/issues/96
-recycleFile :: ( MonadIO m
-               , MonadMask m
-               , MonadReader env m
-               , HasDirs env
-               )
-            => FilePath
-            -> m ()
-recycleFile fp = do
-#if defined(IS_WINDOWS)
-  Dirs { recycleDir } <- getDirs
-  liftIO $ whenM (doesDirectoryExist fp) $ ioError (IOError Nothing InappropriateType "recycleFile" "" Nothing (Just fp))
-  tmp <- liftIO $ createTempDirectory recycleDir "recycleFile"
-  let dest = tmp </> takeFileName fp
-  liftIO (Win32.moveFileEx fp (Just dest) 0)
-    `catch`
-      (\e -> if isPermissionError e {- EXDEV on windows -} then recover (liftIO $ removePathForcibly fp) else throwIO e)
-    `finally`
-      (liftIO $ handleIO (\_ -> pure ()) $ removePathForcibly tmp)
-#else
-  liftIO $ removeFile fp
-#endif
-
-
-rmFile :: ( MonadIO m
-          , MonadMask m
-          )
+rmFile :: (MonadIO m, MonadMask m)
      => FilePath
      -> m ()
 rmFile fp =
 #if defined(IS_WINDOWS)
-  recover (liftIO $ removeFile fp)
+  recovering (fullJitterBackoff 25000 <> limitRetries 10)
+    [\_ -> Handler (\e -> pure $ isPermissionError e)
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
+    ]
+    (\_ -> liftIO $ removeFile fp)
 #else
  liftIO $ removeFile fp
 #endif


-rmDirectoryLink :: (MonadIO m, MonadMask m, MonadReader env m, HasDirs env)
-                => FilePath
-                -> m ()
-rmDirectoryLink fp = 
-#if defined(IS_WINDOWS)
-  recover (liftIO $ removeDirectoryLink fp)
-#else
-  liftIO $ removeDirectoryLink fp
-#endif
-
-
-#if defined(IS_WINDOWS)
-recover :: (MonadIO m, MonadMask m) => m a -> m a
-recover action = 
-  recovering (fullJitterBackoff 25000 <> limitRetries 10)
-    [\_ -> Handler (\e -> pure $ isPermissionError e)
-    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == InappropriateType))
-    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
-    ]
-    (\_ -> action)
-#endif
-
-
-- | Gathering monoidal values
--
-- >>> traverseFold (pure . (:["0"])) ["1","2"]
-- ["1","0","2","0"]
-- >>> traverseFold Just ["1","2","3","4","5"]
-- Just "12345"
--
-- prop> \t -> traverseFold Just t === Just (mconcat t)
+-- 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)

@@ -544,178 +412,16 @@ forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
 forFold = \t -> (`traverseFold` t)


-- | Strip @\\r@ and @\\n@ from 'String's
--
-- >>> stripNewline "foo\n\n\n"
-- "foo"
-- >>> stripNewline "foo\r"
-- "foo"
-- >>> stripNewline "foo"
-- "foo"
--
-- prop> \t -> stripNewline (t <> "\n") === stripNewline t
-- prop> \t -> not (any (isNewLine . c2w) t) ==> stripNewline t == t
+-- | Strip @\\r@ and @\\n@ from 'ByteString's
 stripNewline :: String -> String
-stripNewline = filter (`notElem` "\n\r")
+stripNewline s
+  | null s               = []
+  | head s `elem` "\n\r" = stripNewline (tail s)
+  | otherwise            = head s : stripNewline (tail s)


-- | Strip @\\r@ and @\\n@ from 'Text's
--
-- >>> stripNewline' "foo\n\n\n"
-- "foo"
-- >>> stripNewline' "foo\r"
-- "foo"
-- >>> stripNewline' "foo"
-- "foo"
--
-- prop> \t -> stripNewline' (t <> "\n") === stripNewline' t
-- prop> \t -> not (T.any (isNewLine . c2w) t) ==> stripNewline' t == t
-stripNewline' :: T.Text -> T.Text
-stripNewline' = T.filter (`notElem` "\n\r")
-
-
-- | Is the word8 a newline?
--
-- >>> isNewLine (c2w '\n')
-- True
-- >>> isNewLine (c2w '\r')
-- True
--
-- prop> \w -> w /= _lf && w /= _cr ==> not (isNewLine w)
 isNewLine :: Word8 -> Bool
 isNewLine w
  | w == _lf = True
  | w == _cr = True
  | otherwise = False
-
-
-- | Split on a PVP suffix.
--
-- >>> splitOnPVP "-" "ghc-iserv-dyn-9.3.20210706"
-- ("ghc-iserv-dyn","9.3.20210706")
-- >>> splitOnPVP "-" "ghc-iserv-dyn"
-- ("ghc-iserv-dyn","")
-splitOnPVP :: String -> String -> (String, String)
-splitOnPVP c s = case Split.splitOn c s of
-  []  -> def
-  [_] -> def
-  xs
-    | let l = last xs
-    , (Right _) <- pvp (T.pack l) -> (intercalate c (init xs), l)
-    | otherwise -> def
- where
-  def = (s, "")
-
-
-
-- | Like 'find', but where the test can be monadic.
--
-- >>> findM (Just . C.isUpper) "teST"
-- Just (Just 'S')
-- >>> findM (Just . C.isUpper) "test"
-- Just Nothing
-- >>> findM (Just . const True) ["x",undefined]
-- Just (Just "x")
-findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
-findM ~p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing)
-
-
-- | Drops the given suffix from a list.
--   It returns the original sequence if the sequence doesn't end with the given suffix.
--
-- >>> dropSuffix "!" "Hello World!"
-- "Hello World"
-- >>> dropSuffix "!" "Hello World!!"
-- "Hello World!"
-- >>> dropSuffix "!" "Hello World."
-- "Hello World."
-dropSuffix :: Eq a => [a] -> [a] -> [a]
-dropSuffix a b = fromMaybe b $ stripSuffix a b
-
-- | Return the prefix of the second list if its suffix
--   matches the entire first list.
--
-- >>> stripSuffix "bar" "foobar"
-- Just "foo"
-- >>> stripSuffix ""    "baz"
-- Just "baz"
-- >>> stripSuffix "foo" "quux"
-- Nothing
-stripSuffix :: Eq a => [a] -> [a] -> Maybe [a]
-stripSuffix a b = reverse <$> stripPrefix (reverse a) (reverse b)
-
-
-- | Drops the given prefix from a list.
--   It returns the original sequence if the sequence doesn't start with the given prefix.
--
-- >>> dropPrefix "Mr. " "Mr. Men"
-- "Men"
-- >>> dropPrefix "Mr. " "Dr. Men"
-- "Dr. Men"
-dropPrefix :: Eq a => [a] -> [a] -> [a]
-dropPrefix a b = fromMaybe b $ stripPrefix a b
-
-
-
-- | Break a list into pieces separated by the first
-- list argument, consuming the delimiter. An empty delimiter is
-- invalid, and will cause an error to be raised.
--
-- >>> splitOn "\r\n" "a\r\nb\r\nd\r\ne"
-- ["a","b","d","e"]
-- >>> splitOn "aaa"  "aaaXaaaXaaaXaaa"
-- ["","X","X","X",""]
-- >>> splitOn "x"    "x"
-- ["",""]
-- >>> splitOn "x"    ""
-- [""]
--
-- prop> \s x -> s /= "" ==> intercalate s (splitOn s x) == x
-- prop> \c x -> splitOn [c] x                           == split (==c) x
-splitOn :: Eq a => [a] -> [a] -> [[a]]
-splitOn [] _ = error "splitOn, needle may not be empty"
-splitOn _ [] = [[]]
-splitOn needle haystack = a : if null b then [] else splitOn needle $ drop (length needle) b
-    where (a,b) = breakOn needle haystack
-
-
-- | Splits a list into components delimited by separators,
-- where the predicate returns True for a separator element.  The
-- resulting components do not contain the separators.  Two adjacent
-- separators result in an empty component in the output.
--
-- >>> split (== 'a') "aabbaca"
-- ["","","bb","c",""]
-- >>> split (== 'a') ""
-- [""]
-- >>> split (== ':') "::xyz:abc::123::"
-- ["","","xyz","abc","","123","",""]
-- >>> split (== ',') "my,list,here"
-- ["my","list","here"]
-split :: (a -> Bool) -> [a] -> [[a]]
-split _ [] = [[]]
-split f (x:xs)
-  | f x = [] : split f xs
-  | y:ys <- split f xs = (x:y) : ys
-  | otherwise = [[]]
-
-
-- | Find the first instance of @needle@ in @haystack@.
-- The first element of the returned tuple
-- is the prefix of @haystack@ before @needle@ is matched.  The second
-- is the remainder of @haystack@, starting with the match.
-- If you want the remainder /without/ the match, use 'stripInfix'.
--
-- >>> breakOn "::" "a::b::c"
-- ("a","::b::c")
-- >>> breakOn "/" "foobar"
-- ("foobar","")
--
-- prop> \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack
-breakOn :: Eq a => [a] -> [a] -> ([a], [a])
-breakOn needle haystack | needle `isPrefixOf` haystack = ([], haystack)
-breakOn _ [] = ([], [])
-breakOn needle (x:xs) = first (x:) $ breakOn needle xs
-
-
-
--- a/lib/GHCup/Utils/String/QQ.hs
+++ b/lib/GHCup/Utils/String/QQ.hs
@@ -44,14 +44,15 @@ import           Language.Haskell.TH.Quote
 -- The pattern portion is undefined.
 s :: QuasiQuoter
 s = QuasiQuoter
-  (\s' -> case all isAscii s' of
+  (\s' -> case and $ fmap isAscii s' of
    True  -> (\a -> [|fromString a|]) . trimLeadingNewline . removeCRs $ s'
    False -> fail "Not ascii"
  )
-  (error "Cannot use s as a pattern")
-  (error "Cannot use s as a type")
-  (error "Cannot use s as a dec")
+  (error "Cannot use q as a pattern")
+  (error "Cannot use q as a type")
+  (error "Cannot use q as a dec")
 where
  removeCRs = filter (/= '\r')
  trimLeadingNewline ('\n' : xs) = xs
  trimLeadingNewline xs          = xs
+
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -24,11 +24,8 @@ import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
--
-- Note that when updating this, CI requires that the file exsists AND the same file exists at
-- 'https://www.haskell.org/ghcup/exp/ghcup-<ver>.yaml' with some newlines added.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.6.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.5.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
--- a/lib/System/Console/Terminal/Common.hs
+++ b/lib/System/Console/Terminal/Common.hs
@@ -1,43 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE DeriveTraversable #-}
-
-#if __GLASGOW_HASKELL__ >= 702
-#define LANGUAGE_DeriveGeneric
-{-# LANGUAGE DeriveGeneric #-}
-#endif
-
-module System.Console.Terminal.Common
-  ( Window(..)
-  ) where
-
-import Data.Data (Typeable, Data)
-
-#if __GLASGOW_HASKELL__ < 710
-import Data.Foldable (Foldable)
-import Data.Traversable (Traversable)
-#endif
-
-#ifdef LANGUAGE_DeriveGeneric
-import GHC.Generics
-  ( Generic
-#if __GLASGOW_HASKELL__ >= 706
-  , Generic1
-#endif
-  )
-#endif
-
-- | Terminal window width and height
-data Window a = Window
-  { height :: !a
-  , width  :: !a
-  } deriving
-    ( Show, Eq, Read, Data, Typeable
-    , Foldable, Functor, Traversable
-#ifdef LANGUAGE_DeriveGeneric
-    , Generic
-#if __GLASGOW_HASKELL__ >= 706
-    , Generic1
-#endif
-#endif
-    )
--- a/lib/System/Console/Terminal/Posix.hsc
+++ b/lib/System/Console/Terminal/Posix.hsc
@@ -1,65 +0,0 @@
-{-# LANGUAGE CApiFFI #-}
-
-module System.Console.Terminal.Posix
-  ( size, fdSize, hSize
-  ) where
-
-import System.Console.Terminal.Common
-import Control.Exception (catch)
-import Data.Typeable (cast)
-import Foreign
-import Foreign.C.Error
-import Foreign.C.Types
-import GHC.IO.FD (FD(FD, fdFD))
-import GHC.IO.Handle.Internals (withHandle_)
-import GHC.IO.Handle.Types (Handle, Handle__(Handle__, haDevice))
-#if defined(__GLASGOW_HASKELL__) && (__GLASGOW_HASKELL__ < 706)
-import Prelude hiding (catch)
-#endif
-import System.Posix.Types (Fd(Fd))
-
-#include <sys/ioctl.h>
-#include <unistd.h>
-
-
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
-
-
-- Interesting part of @struct winsize@
-data CWin = CWin CUShort CUShort
-
-instance Storable CWin where
-  sizeOf _ = (#size struct winsize)
-  alignment _ = (#alignment struct winsize)
-  peek ptr = do
-    row <- (#peek struct winsize, ws_row) ptr
-    col <- (#peek struct winsize, ws_col) ptr
-    return $ CWin row col
-  poke ptr (CWin row col) = do
-    (#poke struct winsize, ws_row) ptr row
-    (#poke struct winsize, ws_col) ptr col
-
-
-fdSize :: Integral n => Fd -> IO (Maybe (Window n))
-fdSize (Fd fd) = with (CWin 0 0) $ \ws -> do
-  _ <- throwErrnoIfMinus1 "ioctl" $
-    ioctl fd (#const TIOCGWINSZ) ws
-  CWin row col <- peek ws
-  return . Just $ Window (fromIntegral row) (fromIntegral col)
- `catch`
-  handler
- where
-  handler :: IOError -> IO (Maybe (Window h))
-  handler _ = return Nothing
-
-foreign import capi "sys/ioctl.h ioctl"
-  ioctl :: CInt -> CULong -> Ptr CWin -> IO CInt
-
-size :: Integral n => IO (Maybe (Window n))
-size = fdSize (Fd (#const STDOUT_FILENO))
-
-hSize :: Integral n => Handle -> IO (Maybe (Window n))
-hSize h = withHandle_ "hSize" h $ \Handle__ { haDevice = dev } ->
-  case cast dev of
-    Nothing -> return Nothing
-    Just FD { fdFD = fd } -> fdSize (Fd fd)
--- a/scoop-better-shimexe/LICENSE-MIT
+++ b/scoop-better-shimexe/LICENSE-MIT
@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Grégoire Geis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/scoop-better-shimexe/LICENSE-UNLICENSE
+++ b/scoop-better-shimexe/LICENSE-UNLICENSE
@@ -1,10 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
-
-In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and 
-successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org/>
--- a/scoop-better-shimexe/README.md
+++ b/scoop-better-shimexe/README.md
@@ -1,71 +0,0 @@
-# `shim.c`
-
-[`shim.c`](./shim.c) is a simple Windows program that, when started:
-1. Looks for a file with the exact same name as the running program, but with
-   the extension `shim` (e.g. `C:\bin\foo.exe` will read the file `C:\bin\foo.shim`).
-2. Reads and [parses](#shim-format) the files into a
-   [Scoop](https://github.com/lukesampson/scoop) shim format.
-3. Executes the target executable with the given arguments.
-
-`shim.c` was originally made to replace [Scoop](https://github.com/lukesampson/scoop)'s
-[`shim.cs`](https://github.com/lukesampson/scoop/blob/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe/shim.cs)
-since it had several important flaws:
-1. [It was made in C#](https://github.com/lukesampson/scoop/tree/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe),
-   and thus required an instantiation of a .NET command line app everytime it was started,
-   which can make a command run much slower than if it had been ran directly;
-2. [It](https://github.com/lukesampson/scoop/issues/2339) [did](https://github.com/lukesampson/scoop/issues/1896)
-   [not](https://github.com/felixse/FluentTerminal/issues/221) handle Ctrl+C and other
-   signals correctly, which could be quite infuriating (and essentially killing REPLs and long-running apps).
-
-[`shim.c`](./shim.c) is:
- **Faster**, because it does not use the .NET Framework, and parses the `.shim` file in a simpler way.
- **More efficient**, because by the time the target of the shim is started, all allocated memory will have been freed.
- And more importantly, it **works better**:
-  - Signals originating from pressing `Ctrl+C` are ignored, and therefore handled directly by the spawned child.
-    Your processes and REPLs will no longer close when pressing `Ctrl+C`.
-  - Children are automatically killed when the shim process is killed. No more orphaned processes and weird behaviors.
-
-> **Note**: This project is not affiliated with [Scoop](https://github.com/lukesampson/scoop).
-
-
-## Installation for Scoop
-
- In a Visual Studio command prompt, run `cl /O1 shim.c`.
- Replace any `.exe` in `scoop\shims` by `shim.exe`.
-
-An additional script, `repshims.bat`, is provided. It will replace all `.exe`s in the user's Scoop directory
-by `shim.exe`.
-
-
-## Example
-
-Given the following shim `gs.shim`:
-```
-path = C:\Program Files\Git\git.exe
-args = status -u
-```
-
-In this directory, where `gs.exe` is the compiled `shim.c`:
-```
-C:\Bin\
-   gs.exe
-   gs.shim
-```
-
-Then calling `gs -s` will run the program `C:\Program Files\Git\git.exe status -u -s`.
-
-
-## Shim format
-
-Shims follow the same format as Scoop's shims: line-separated `key = value` pairs.
-```
-path = C:\Program Files\Git\git.exe
-args = status -uno
-```
-
-`path` is a required value, but `args` can be omitted. Also, do note that lines **must** end with a line feed.
-
-
-## License
-
-`SPDX-License-Identifier: MIT OR Unlicense`
--- a/scoop-better-shimexe/repshims.bat
+++ b/scoop-better-shimexe/repshims.bat
@@ -1,15 +0,0 @@
-@echo off
-
-if not defined SCOOP set SCOOP=%USERPROFILE%\scoop
-
-for %%x in ("%SCOOP%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)
-
-if not defined SCOOP_GLOBAL set SCOOP_GLOBAL=%ProgramData%\scoop
-
-for %%x in ("%SCOOP_GLOBAL%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)
--- a/scoop-better-shimexe/shim.c
+++ b/scoop-better-shimexe/shim.c
@@ -1,256 +0,0 @@
-#pragma comment(lib, "SHELL32.LIB")
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <wchar.h>
-#include <Windows.h>
-
-#ifndef ERROR_ELEVATION_REQUIRED
-#  define ERROR_ELEVATION_REQUIRED 740
-#endif
-
-#define MAX_FILENAME_SIZE 512
-
-BOOL WINAPI ctrlhandler(DWORD fdwCtrlType)
-{
-  switch (fdwCtrlType) {
-    // Ignore all events, and let the child process
-    // handle them.
-    case CTRL_C_EVENT:
-    case CTRL_CLOSE_EVENT:
-    case CTRL_LOGOFF_EVENT:
-    case CTRL_BREAK_EVENT:
-    case CTRL_SHUTDOWN_EVENT:
-      return TRUE;
-
-    default:
-      return FALSE;
-  }
-}
-
-int compute_program_length(const wchar_t* commandline)
-{
-  int i = 0;
-
-  if (commandline[0] == L'"') {
-    // Wait till end of string
-    i++;
-
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L'"')
-        return i;
-    }
-  } else {
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L' ')
-        return i;
-    }
-  }
-}
-
-int main()
-{
-  DWORD exit_code = 0;
-
-  wchar_t* path = NULL;
-  wchar_t* args = NULL;
-  wchar_t* cmd = NULL;
-
-  // Find filename of current executable.
-  wchar_t filename[MAX_FILENAME_SIZE + 2];
-  const unsigned int filename_size = GetModuleFileNameW(NULL, filename, MAX_FILENAME_SIZE);
-
-  if (filename_size >= MAX_FILENAME_SIZE) {
-    fprintf(stderr, "The filename of the program is too long to handle.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Use filename of current executable to find .shim
-  filename[filename_size - 3] = L's';
-  filename[filename_size - 2] = L'h';
-  filename[filename_size - 1] = L'i';
-  filename[filename_size - 0] = L'm';
-  filename[filename_size + 1] =  0 ;
-
-  FILE* shim_file;
-
-  if ((shim_file = _wfsopen(filename, L"r,ccs=UTF-8", _SH_DENYNO)) == NULL) {
-    fprintf(stderr, "Cannot open shim file for read.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  size_t command_length = 256;
-  size_t path_length;
-  size_t args_length;
-
-  // Read shim
-  wchar_t linebuf[8192];
-
-  for (;;) {
-    const wchar_t* line = fgetws(linebuf, 8192, shim_file);
-
-    if (line == NULL)
-      break;
-
-    if (line[4] != L' ' || line[5] != L'=' || line[6] != L' ')
-      continue;
-
-    const int linelen = wcslen(line);
-    const int len = linelen - 8 + (line[linelen - 1] != '\n');
-
-    if (line[0] == L'p' && line[1] == L'a' && line[2] == L't' && line[3] == L'h') {
-      // Reading path
-      path = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(path, line + 7, len);
-
-      command_length += len;
-      path_length = len;
-
-      continue;
-    }
-
-    if (line[0] == L'a' && line[1] == L'r' && line[2] == L'g' && line[3] == L's') {
-      // Reading args
-      args = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(args, line + 7, len);
-
-      command_length += len + 1;
-      args_length = len;
-
-      continue;
-    }
-
-    continue;
-  }
-
-  fclose(shim_file);
-
-  if (path == NULL) {
-    fprintf(stderr, "Could not read shim file.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Find length of command to run
-  wchar_t* given_cmd = GetCommandLineW();
-  const int program_length = compute_program_length(given_cmd);
-
-  given_cmd += program_length;
-
-  const int given_length = wcslen(given_cmd);
-
-  command_length += given_length;
-
-  // Start building command to run, using '[path] [args]', as given by shim.
-  cmd = calloc(command_length, sizeof(wchar_t));
-  int cmd_i = 0;
-
-  wmemcpy(cmd, path, path_length);
-  cmd[path_length] = ' ';
-  cmd_i += path_length + 1;
-
-  if (args != NULL) {
-    wmemcpy(cmd + path_length + 1, args, args_length);
-    cmd[path_length + args_length + 1] = ' ';
-    cmd_i += args_length + 1;
-  }
-
-  // Copy all given arguments to command
-  wmemcpy(cmd + cmd_i, given_cmd, given_length);
-
-  // Find out if the target program is a console app
-  SHFILEINFOW sfi = {0};
-  const BOOL is_windows_app = HIWORD(SHGetFileInfoW(path, -1, &sfi, sizeof(sfi), SHGFI_EXETYPE));
-
-  if (is_windows_app)
-    // Unfortunately, this technique will still show a window for a fraction of time,
-    // but there's just no workaround.
-    FreeConsole();
-
-  // Create job object, which can be attached to child processes
-  // to make sure they terminate when the parent terminates as well.
-  JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli = {0};
-  HANDLE jobHandle = CreateJobObject(NULL, NULL);
-
-  jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK;
-  SetInformationJobObject(jobHandle, JobObjectExtendedLimitInformation, &jeli, sizeof(jeli));
-
-  // Start subprocess
-  STARTUPINFOW si = {0};
-  PROCESS_INFORMATION pi = {0};
-
-  if (CreateProcessW(NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {
-    AssignProcessToJobObject(jobHandle, pi.hProcess);
-    ResumeThread(pi.hThread);
-  } else {
-    if (GetLastError() == ERROR_ELEVATION_REQUIRED) {
-      // We must elevate the process, which is (basically) impossible with
-      // CreateProcess, and therefore we fallback to ShellExecuteEx,
-      // which CAN create elevated processes, at the cost of opening a new separate
-      // window.
-      // Theorically, this could be fixed (or rather, worked around) using pipes
-      // and IPC, but... this is a question for another day.
-      SHELLEXECUTEINFOW sei = {0};
-
-      sei.cbSize       = sizeof(SHELLEXECUTEINFOW);
-      sei.fMask        = SEE_MASK_NOCLOSEPROCESS;
-      sei.lpFile       = path;
-      sei.lpParameters = cmd + path_length + 1;
-      sei.nShow        = SW_SHOW;
-
-      if (!ShellExecuteExW(&sei)) {
-        fprintf(stderr, "Unable to create elevated process: error %li.", GetLastError());
-
-        exit_code = 1;
-        goto cleanup;
-      }
-
-      pi.hProcess = sei.hProcess;
-    } else {
-      fprintf(stderr, "Could not create process with command '%ls'.\n", cmd);
-
-      exit_code = 1;
-      goto cleanup;
-    }
-  }
-
-  // Ignore Ctrl-C and other signals
-  if (!SetConsoleCtrlHandler(ctrlhandler, TRUE))
-    fprintf(stderr, "Could not set control handler; Ctrl-C behavior may be invalid.\n");
-
-  // Wait till end of process
-  WaitForSingleObject(pi.hProcess, INFINITE);
-
-  GetExitCodeProcess(pi.hProcess, &exit_code);
-
-  // Dispose of everything
-  CloseHandle(pi.hThread);
-  CloseHandle(pi.hProcess);
-  CloseHandle(jobHandle);
-
-cleanup:
-
-  // Free obsolete buffers
-  free(path);
-  free(args);
-  free(cmd);
-
-  return (int)exit_code;
-}
--- a/scripts/bootstrap/bootstrap-haskell
+++ b/scripts/bootstrap/bootstrap-haskell
@@ -1,695 +0,0 @@
-#!/bin/sh
-
-# Main settings:
-#   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
-#   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
-#   * BOOTSTRAP_HASKELL_MINIMAL - any nonzero value to only install ghcup
-#   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
-#   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
-#   * BOOTSTRAP_HASKELL_GHC_VERSION - the ghc version to install
-#   * BOOTSTRAP_HASKELL_CABAL_VERSION - the cabal version to install
-#   * BOOTSTRAP_HASKELL_INSTALL_STACK - whether to install latest stack
-#   * BOOTSTRAP_HASKELL_INSTALL_HLS - whether to install latest hls
-#   * BOOTSTRAP_HASKELL_ADJUST_BASHRC - whether to adjust PATH in bashrc (prepend)
-#   * BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG - whether to adjust mingw paths in cabal.config on windows
-
-# License: LGPL-3.0
-
-
-# safety subshell to avoid executing anything in case this script is not downloaded properly
-(
-
-plat="$(uname -s)"
-arch=$(uname -m)
-ghver="0.1.17"
-base_url="https://downloads.haskell.org/~ghcup"
-
-export GHCUP_SKIP_UPDATE_CHECK=yes
-
-case "${plat}" in
-        MSYS*|MINGW*)
-			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
-			GHCUP_DIR=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup")
-			GHCUP_BIN=$(cygpath -u "${GHCUP_INSTALL_BASE_PREFIX}/ghcup/bin")
-			: "${GHCUP_MSYS2:=${GHCUP_DIR}/msys64}"
-			;;
-		*)
-			: "${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
-			;;
-esac
-
-: "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
-: "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"
-
-
-die() {
-    if [ -n "${NO_COLOR}" ] ; then
-        (>&2 printf "%s\\n" "$1")
-    else
-        (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
-    fi
-    exit 2
-}
-
-warn() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;35m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;35m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
-}
-
-yellow() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;33m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;33m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
-}
-
-green() {
-    if [ -n "${NO_COLOR}" ] ; then
-        printf "%s\\n" "$1"
-    else
-        case "${plat}" in
-                MSYS*|MINGW*)
-                    echo -e "\\033[0;32m$1\\033[0m"
-                    ;;
-                *)
-                    printf "\\033[0;32m%s\\033[0m\\n" "$1"
-                    ;;
-        esac
-    fi
-}
-
-edo() {
-    "$@" || die "\"$*\" failed!"
-}
-
-eghcup() {
-	edo _eghcup "$@"
-}
-
-_eghcup() {
-	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
-		args="-s ${BOOTSTRAP_HASKELL_YAML}"
-	fi
-    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        "${GHCUP_BIN}/ghcup" ${args} "$@"
-    else
-        "${GHCUP_BIN}/ghcup" ${args} --verbose "$@"
-    fi
-}
-
-_done() {
-	echo
-	echo "==============================================================================="
-	case "${plat}" in
-			MSYS*|MINGW*)
-				green
-				green "All done!"
-				green
-				green "In a new powershell or cmd.exe session, now you can..."
-				green
-				green "Start a simple repl via:"
-				green "  ghci"
-				green
-				green "Start a new haskell project in the current directory via:"
-				green "  cabal init --interactive"
-				green
-				green "Install other GHC versions and tools via:"
-				green "  ghcup list"
-				green "  ghcup install <tool> <version>"
-				green
-				green "To install system libraries and update msys2/mingw64,"
-				green "open the \"Mingw haskell shell\""
-				green "and the \"Mingw package management docs\""
-				green "desktop shortcuts."
-				;;
-			*)
-				green
-				green "All done!"
-				green
-				green "To start a simple repl, run:"
-				green "  ghci"
-				green
-				green "To start a new haskell project in the current directory, run:"
-				green "  cabal init --interactive"
-				green
-				green "To install other GHC versions and tools, run:"
-				green "  ghcup tui"
-				;;
-
-	esac
-
-
-	exit 0
-}
-
-download_ghcup() {
-
-    case "${plat}" in
-        "linux"|"Linux")
-			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}
-					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
-						_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}
-					;;
-				armv7*)
-					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
-					;;
-				aarch64|arm64|armv8l)
-					# 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}/armv7-linux-ghcup-${ghver}
-					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
-						_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
-					else
-						die "Unknown long bit size: $(getconf LONG_BIT)"
-					fi
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        "FreeBSD"|"freebsd")
-			case "${arch}" in
-				x86_64|amd64)
-					;;
-				i*86)
-					die "i386 currently not supported!"
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
-            ;;
-        "Darwin"|"darwin")
-			case "${arch}" in
-				x86_64|amd64)
-					_url=${base_url}/${ghver}/x86_64-apple-darwin-ghcup-${ghver}
-					;;
-				aarch64|arm64|armv8l)
-					_url=${base_url}/${ghver}/aarch64-apple-darwin-ghcup-${ghver}
-					;;
-				i*86)
-					die "i386 currently not supported!"
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        MSYS*|MINGW*)
-			case "${arch}" in
-				x86_64|amd64)
-					_url=${base_url}/${ghver}/x86_64-mingw64-ghcup-${ghver}.exe
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        *) die "Unknown platform: ${plat}"
-			;;
-    esac
-    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}"
-
-	# we may overwrite this in adjust_bashrc
-	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
-		EOF
-
-	# shellcheck disable=SC1090
-    edo . "${GHCUP_DIR}"/env
-    eghcup upgrade
-}
-
-# Figures out the users login shell and sets
-# GHCUP_PROFILE_FILE and MY_SHELL variables.
-find_shell() {
-	case $SHELL in
-		*/zsh) # login shell is zsh
-			GHCUP_PROFILE_FILE="$HOME/.zshrc"
-			MY_SHELL="zsh" ;;
-		*/bash) # login shell is bash
-			GHCUP_PROFILE_FILE="$HOME/.bashrc"
-			MY_SHELL="bash" ;;
-		*/sh) # login shell is sh, but might be a symlink to bash or zsh
-			if [ -n "${BASH}" ] ; then
-				GHCUP_PROFILE_FILE="$HOME/.bashrc"
-				MY_SHELL="bash"
-			elif [ -n "${ZSH_VERSION}" ] ; then
-				GHCUP_PROFILE_FILE="$HOME/.zshrc"
-				MY_SHELL="zsh"
-			else
-				return
-			fi
-			;;
-		*/fish) # login shell is fish
-			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
-			MY_SHELL="fish" ;;
-		*) return ;;
-	esac
-}
-
-# Ask user if they want to adjust the bashrc.
-ask_bashrc() {
-	if [ -n "${BOOTSTRAP_HASKELL_ADJUST_BASHRC}" ] ; then
-		return 1
-	elif [ -z "${MY_SHELL}" ] ; then
-		return 0
-	fi
-
-	while true; do
-		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-			echo "-------------------------------------------------------------------------------"
-
-			warn ""
-			warn "Detected ${MY_SHELL} shell on your system..."
-			warn "Do you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\"?"
-			warn ""
-			warn "[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is \"P\")."
-			warn ""
-
-			read -r bashrc_answer </dev/tty
-		else
-			return 0
-		fi
-		case $bashrc_answer in
-			[Pp]* | "")
-				return 1
-				;;
-			[Aa]*)
-				return 2
-				;;
-			[Nn]*)
-				return 0;;
-			*)
-				echo "Possible choices are:"
-				echo
-				echo "P - Yes, prepend to PATH, taking precedence (default)"
-				echo "A - Yes, append to PATH"
-				echo "N - No, don't mess with my configuration"
-				echo
-				echo "Please make your choice and press ENTER."
-				;;
-		esac
-	done
-
-	unset bashrc_answer
-}
-
-# Needs 'find_shell' to be called beforehand.
-adjust_bashrc() {
-	case $1 in
-		1)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
-				EOF
-			;;
-		2)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$PATH:\$HOME/.cabal/bin:${GHCUP_BIN}"
-				EOF
-			;;
-		*) ;;
-	esac
-
-	case $1 in
-		1 | 2)
-			case $MY_SHELL in
-				"")
-					warn_path "Couldn't figure out login shell!"
-					return
-					;;
-				fish)
-					mkdir -p "${GHCUP_PROFILE_FILE%/*}"
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					case $1 in
-						1)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-						2)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin \$PATH $GHCUP_BIN # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-					esac
-					break ;;
-				bash)
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-					case "${plat}" in
-						"Darwin"|"darwin")
-							if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
-								echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
-							fi
-							;;
-						MSYS*|MINGW*)
-							if [ ! -e "${HOME}/.bash_profile" ] ; then
-								echo '# generated by ghcup' > "${HOME}/.bash_profile"
-								echo 'test -f ~/.profile && . ~/.profile' >> "${HOME}/.bash_profile"
-								echo 'test -f ~/.bashrc && . ~/.bashrc' >> "${HOME}/.bash_profile"
-							fi
-							;;
-					esac
-					break ;;
-
-				zsh)
-					sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-					break ;;
-			esac
-			echo
-			echo "==============================================================================="
-			echo
-			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."
-			return
-			;;
-		*)
-			warn_path
-			;;
-	esac
-}
-
-warn_path() {
-	echo
-	echo "==============================================================================="
-	echo
-	[ -n "$1" ] && warn "$1"
-	yellow "In order to run ghc and cabal, you need to adjust your PATH variable."
-	yellow "To do so, you may want to run 'source $GHCUP_DIR/env' in your current terminal"
-	yellow "session as well as your shell configuration (e.g. ~/.bashrc)."
-
-}
-
-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_MSYS2"/usr/bin), $(cygpath -w "$GHCUP_MSYS2"/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/lib)" -f init
-}
-
-ask_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				if [ -n "${BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG}" ] ; then
-					return 1
-				fi
-
-				if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-					echo "-------------------------------------------------------------------------------"
-					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]* | "")
-								return 1 ;;
-							[Nn]*)
-								return 0 ;;
-							*)
-								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
-					return 1
-				fi
-				;;
-	esac
-
-	unset mingw_answer
-
-    return 0
-}
-
-do_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-		case $1 in
-			1)
-				adjust_cabal_config
-				;;
-			0)
-				echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
-				echo "And set the environment variable GHCUP_MSYS2 to the root path of your msys2 installation."
-				sleep 5
-				return ;;
-			*) ;;
-		esac
-	esac
-}
-
-ask_hls() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_HLS}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install haskell-language-server (HLS)?"
-		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
-
-			case $hls_answer in
-				[Yy]*)
-					return 1
-					;;
-				[Nn]* | "")
-					return 0
-					;;
-				*)
-					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
-	else
-		return 0
-	fi
-
-	unset hls_answer
-}
-
-ask_stack() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_STACK}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install stack?"
-		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]*)
-					return 1 ;;
-				[Nn]* | "")
-					return 0 ;;
-				*)
-					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
-	else
-		return 0
-	fi
-
-	unset stack_answer
-}
-
-
-find_shell
-
-
-echo
-echo "Welcome to Haskell!"
-echo
-echo "This script will download and install the following binaries:"
-echo "  * ghcup - The Haskell toolchain installer"
-echo "  * ghc   - The Glasgow Haskell Compiler"
-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:"
-	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."
-fi
-echo
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    warn "Press ENTER to proceed or ctrl-c to abort."
-    warn "Note that this script can be re-run at any given time."
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-ask_bashrc
-ask_bashrc_answer=$?
-ask_cabal_config_init
-ask_cabal_config_init_answer=$?
-if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
-	ask_hls
-	ask_hls_answer=$?
-	ask_stack
-	ask_stack_answer=$?
-fi
-
-edo mkdir -p "${GHCUP_BIN}"
-
-if command -V "ghcup" >/dev/null 2>&1 ; then
-    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        _eghcup upgrade || download_ghcup
-    fi
-else
-	download_ghcup
-fi
-
-echo
-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
-    warn "Press ENTER to proceed or ctrl-c to abort."
-    warn "Installation may take a while."
-    echo
-
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
-	eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-
-	eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-	eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-
-	do_cabal_config_init $ask_cabal_config_init_answer
-
-	edo cabal new-update
-else # don't install ghc and cabal
-	case "${plat}" in
-			MSYS*|MINGW*)
-				# need to bootstrap cabal to initialize config on windows
-				# we'll remove it afterwards
-				tmp_dir="$(mktemp -d)"
-				eghcup --cache install cabal -i "${tmp_dir}" "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-				PATH="${tmp_dir}:$PATH" do_cabal_config_init $ask_cabal_config_init_answer
-				rm "${tmp_dir}/cabal"
-				unset tmp_dir
-				;;
-			*)
-				;;
-	esac
-fi
-
-case $ask_hls_answer in
-	1)
-		_eghcup --cache install hls || warn "HLS installation failed, continuing anyway"
-		;;
-	*) ;;
-esac
-
-case $ask_stack_answer in
-	1)
-		_eghcup --cache install stack || warn "Stack installation failed, continuing anyway"
-		;;
-	*) ;;
-esac
-
-
-adjust_bashrc $ask_bashrc_answer
-
-
-_done
-
-)
-
-# vim: tabstop=4 shiftwidth=4 expandtab
--- a/scripts/dev/refreeze.sh
+++ b/scripts/dev/refreeze.sh
@@ -1,27 +0,0 @@
-#!/bin/sh
-
-set -xue
-
-rm -f cabal.*.project
-rm -f cabal.*.project.freeze
-
-for ghc_ver in "$@" ; do
-	# shellcheck disable=SC3060
-	project_file=cabal.ghc${ghc_ver//./}.project
-
-	cp cabal.project "${project_file}"
-	case "$(uname -s)" in
-        MSYS*|MINGW*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}"
-			;;
-		*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}" -ftui -finternal-downloader
-			;;
-	esac
-
-
-	echo "" >> "${project_file}"
-	echo "with-compiler: ghc-${ghc_ver}" >> "${project_file}"
-
-	sed -i -e '/ghcup/d' "${project_file}".freeze
-done
--- a/scripts/shell-completions/bash
+++ b/scripts/shell-completions/bash
--- a/scripts/shell-completions/fish
+++ b/scripts/shell-completions/fish
--- a/scripts/shell-completions/zsh
+++ b/scripts/shell-completions/zsh
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,44 +1,43 @@
-resolver: lts-18.2
+resolver: lts-17.11

 packages:
  - .

 extra-deps:
-  - git: https://github.com/hasufell/libarchive
-    commit: 8587aab78dd515928024ecd82c8f215e06db85cd
+  - git: https://github.com/hasufell/text-conversions.git
+    commit: 9abf0e5e5664a3178367597c32db19880477a53c
+
+  - git: https://github.com/Bodigrim/tar
+    commit: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf

  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
-  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
  - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
-  - haskus-utils-data-1.4@sha256:bfa94363b94b14779edd6834fbd59dbb847c3d7b8f48e3844f456ffdc077da4a,1466
+  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
  - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
-  - haskus-utils-variant-3.1@sha256:e602dd23e068c98d03c1027af20503addef8df6368577622453f44ccabea2a5b,2159
+  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
  - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
-  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
  - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
-  - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
-  - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
-  - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
-  - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
  - regex-posix-clib-2.7
  - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
  - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469
  - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
+  - zip-1.7.1@sha256:0ce03d0fbffba47c1ab6fbb9166f8ba5373d828d78587df21b7e9d7bb150f929,3918

 flags:
  http-io-streams:
@@ -50,21 +49,7 @@ flags:
  regex-posix:
    _regex-posix-clib: true

-  aeson-pretty:
-    lib-only: true
-
-  cabal-plan:
-    exe: false
-
 ghc-options:
  "$locals": -O2
  streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
  ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-
-build:
-  test: true
-  test-arguments:
-    no-run-tests: true
-  bench: true
-  benchmark-opts:
-    no-run-benchmarks: true
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@@ -66,7 +66,7 @@ instance Arbitrary ByteString where
    ---------------------

 instance Arbitrary Scheme where
-  arbitrary = elements [ Scheme "http", Scheme "https" ]
+  arbitrary = oneof [ pure (Scheme "http"), pure (Scheme "https") ]

 instance Arbitrary Host where
  arbitrary = genericArbitrary
--- a/test/GHCup/Types/JSONSpec.hs
+++ b/test/GHCup/Types/JSONSpec.hs
@@ -13,5 +13,4 @@ import           Test.Hspec

 spec :: Spec
 spec = do
-  roundtripAndGoldenSpecsWithSettings (defaultSettings { goldenDirectoryOption = CustomDirectoryName "test/golden" }) (Proxy @GHCupInfo)
-
+  roundtripAndGoldenSpecs (Proxy @GHCupInfo)
--- a/www/Discord-Logo-Black.svg
+++ b/www/Discord-Logo-Black.svg
@@ -1,10 +0,0 @@
-<svg width="71" height="55" viewBox="0 0 71 55" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0)">
-<path d="M60.1045 4.8978C55.5792 2.8214 50.7265 1.2916 45.6527 0.41542C45.5603 0.39851 45.468 0.440769 45.4204 0.525289C44.7963 1.6353 44.105 3.0834 43.6209 4.2216C38.1637 3.4046 32.7345 3.4046 27.3892 4.2216C26.905 3.0581 26.1886 1.6353 25.5617 0.525289C25.5141 0.443589 25.4218 0.40133 25.3294 0.41542C20.2584 1.2888 15.4057 2.8186 10.8776 4.8978C10.8384 4.9147 10.8048 4.9429 10.7825 4.9795C1.57795 18.7309 -0.943561 32.1443 0.293408 45.3914C0.299005 45.4562 0.335386 45.5182 0.385761 45.5576C6.45866 50.0174 12.3413 52.7249 18.1147 54.5195C18.2071 54.5477 18.305 54.5139 18.3638 54.4378C19.7295 52.5728 20.9469 50.6063 21.9907 48.5383C22.0523 48.4172 21.9935 48.2735 21.8676 48.2256C19.9366 47.4931 18.0979 46.6 16.3292 45.5858C16.1893 45.5041 16.1781 45.304 16.3068 45.2082C16.679 44.9293 17.0513 44.6391 17.4067 44.3461C17.471 44.2926 17.5606 44.2813 17.6362 44.3151C29.2558 49.6202 41.8354 49.6202 53.3179 44.3151C53.3935 44.2785 53.4831 44.2898 53.5502 44.3433C53.9057 44.6363 54.2779 44.9293 54.6529 45.2082C54.7816 45.304 54.7732 45.5041 54.6333 45.5858C52.8646 46.6197 51.0259 47.4931 49.0921 48.2228C48.9662 48.2707 48.9102 48.4172 48.9718 48.5383C50.038 50.6034 51.2554 52.5699 52.5959 54.435C52.6519 54.5139 52.7526 54.5477 52.845 54.5195C58.6464 52.7249 64.529 50.0174 70.6019 45.5576C70.6551 45.5182 70.6887 45.459 70.6943 45.3942C72.1747 30.0791 68.2147 16.7757 60.1968 4.9823C60.1772 4.9429 60.1437 4.9147 60.1045 4.8978ZM23.7259 37.3253C20.2276 37.3253 17.3451 34.1136 17.3451 30.1693C17.3451 26.225 20.1717 23.0133 23.7259 23.0133C27.308 23.0133 30.1626 26.2532 30.1066 30.1693C30.1066 34.1136 27.28 37.3253 23.7259 37.3253ZM47.3178 37.3253C43.8196 37.3253 40.9371 34.1136 40.9371 30.1693C40.9371 26.225 43.7636 23.0133 47.3178 23.0133C50.9 23.0133 53.7545 26.2532 53.6986 30.1693C53.6986 34.1136 50.9 37.3253 47.3178 37.3253Z" fill="#23272A"/>
-</g>
-<defs>
-<clipPath id="clip0">
-<rect width="71" height="55" fill="white"/>
-</clipPath>
-</defs>
-</svg>
--- a/www/Matrix_logo.svg
+++ b/www/Matrix_logo.svg
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg version="1.1" viewBox="0 0 75 32" xmlns="http://www.w3.org/2000/svg" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
-<title>Matrix (protocol) logo</title>
- <g fill="#040404">
-  <path d="m0.936 0.732v30.52h2.194v0.732h-3.035v-31.98h3.034v0.732zm8.45 9.675v1.544h0.044a4.461 4.461 0 0 1 1.487-1.368c0.58-0.323 1.245-0.485 1.993-0.485 0.72 0 1.377 0.14 1.972 0.42 0.595 0.279 1.047 0.771 1.355 1.477 0.338-0.5 0.796-0.941 1.377-1.323 0.58-0.383 1.266-0.574 2.06-0.574 0.602 0 1.16 0.074 1.674 0.22 0.514 0.148 0.954 0.383 1.322 0.707 0.366 0.323 0.653 0.746 0.859 1.268 0.205 0.522 0.308 1.15 0.308 1.887v7.633h-3.127v-6.464c0-0.383-0.015-0.743-0.044-1.082a2.305 2.305 0 0 0-0.242-0.882 1.473 1.473 0 0 0-0.584-0.596c-0.257-0.146-0.606-0.22-1.047-0.22-0.44 0-0.796 0.085-1.068 0.253-0.272 0.17-0.485 0.39-0.639 0.662a2.654 2.654 0 0 0-0.308 0.927 7.074 7.074 0 0 0-0.078 1.048v6.354h-3.128v-6.398c0-0.338-7e-3 -0.673-0.021-1.004a2.825 2.825 0 0 0-0.188-0.916 1.411 1.411 0 0 0-0.55-0.673c-0.258-0.168-0.636-0.253-1.135-0.253a2.33 2.33 0 0 0-0.584 0.1 1.94 1.94 0 0 0-0.705 0.374c-0.228 0.184-0.422 0.449-0.584 0.794-0.161 0.346-0.242 0.798-0.242 1.357v6.619h-3.129v-11.41zm16.46 1.677a3.751 3.751 0 0 1 1.233-1.17 5.37 5.37 0 0 1 1.685-0.629 9.579 9.579 0 0 1 1.884-0.187c0.573 0 1.153 0.04 1.74 0.121 0.588 0.081 1.124 0.24 1.609 0.475 0.484 0.235 0.88 0.562 1.19 0.981 0.308 0.42 0.462 0.975 0.462 1.666v5.934c0 0.516 0.03 1.008 0.088 1.478 0.058 0.471 0.161 0.824 0.308 1.06h-3.171a4.435 4.435 0 0 1-0.22-1.104c-0.5 0.515-1.087 0.876-1.762 1.081a7.084 7.084 0 0 1-2.071 0.31c-0.544 0-1.05-0.067-1.52-0.2a3.472 3.472 0 0 1-1.234-0.617 2.87 2.87 0 0 1-0.826-1.059c-0.199-0.426-0.298-0.934-0.298-1.522 0-0.647 0.114-1.18 0.342-1.6 0.227-0.419 0.52-0.753 0.881-1.004 0.36-0.25 0.771-0.437 1.234-0.562 0.462-0.125 0.929-0.224 1.399-0.298 0.47-0.073 0.932-0.132 1.387-0.176 0.456-0.044 0.86-0.11 1.212-0.199 0.353-0.088 0.631-0.217 0.837-0.386s0.301-0.415 0.287-0.74c0-0.337-0.055-0.606-0.166-0.804a1.217 1.217 0 0 0-0.44-0.464 1.737 1.737 0 0 0-0.639-0.22 5.292 5.292 0 0 0-0.782-0.055c-0.617 0-1.101 0.132-1.454 0.397-0.352 0.264-0.558 0.706-0.617 1.323h-3.128c0.044-0.735 0.227-1.345 0.55-1.83zm6.179 4.423a5.095 5.095 0 0 1-0.639 0.165 9.68 9.68 0 0 1-0.716 0.11c-0.25 0.03-0.5 0.067-0.749 0.11a5.616 5.616 0 0 0-0.694 0.177 2.057 2.057 0 0 0-0.594 0.298c-0.17 0.125-0.305 0.284-0.408 0.474-0.103 0.192-0.154 0.434-0.154 0.728 0 0.28 0.051 0.515 0.154 0.706 0.103 0.192 0.242 0.342 0.419 0.453 0.176 0.11 0.381 0.187 0.617 0.231 0.234 0.044 0.477 0.066 0.726 0.066 0.617 0 1.094-0.102 1.432-0.309 0.338-0.205 0.587-0.452 0.75-0.739 0.16-0.286 0.26-0.576 0.297-0.87 0.036-0.295 0.055-0.53 0.055-0.707v-1.17a1.4 1.4 0 0 1-0.496 0.277zm11.86-6.1v2.096h-2.291v5.647c0 0.53 0.088 0.883 0.264 1.059 0.176 0.177 0.529 0.265 1.057 0.265 0.177 0 0.345-7e-3 0.507-0.022 0.161-0.015 0.316-0.037 0.463-0.066v2.426a7.49 7.49 0 0 1-0.882 0.089 21.67 21.67 0 0 1-0.947 0.022c-0.484 0-0.944-0.034-1.377-0.1a3.233 3.233 0 0 1-1.145-0.386 2.04 2.04 0 0 1-0.782-0.816c-0.191-0.353-0.287-0.816-0.287-1.39v-6.728h-1.894v-2.096h1.894v-3.42h3.129v3.42h2.29zm4.471 0v2.118h0.044a3.907 3.907 0 0 1 1.454-1.754 4.213 4.213 0 0 1 1.036-0.497 3.734 3.734 0 0 1 1.145-0.176c0.206 0 0.433 0.037 0.683 0.11v2.912a5.862 5.862 0 0 0-0.528-0.077 5.566 5.566 0 0 0-0.595-0.033c-0.573 0-1.058 0.096-1.454 0.287a2.52 2.52 0 0 0-0.958 0.783 3.143 3.143 0 0 0-0.518 1.158 6.32 6.32 0 0 0-0.154 1.434v5.14h-3.128v-11.4zm5.684-1.765v-2.582h3.128v2.582h-3.127zm3.128 1.765v11.4h-3.127v-11.4h3.128zm1.63 0h3.569l2.005 2.978 1.982-2.978h3.459l-3.745 5.339 4.208 6.067h-3.57l-2.378-3.596-2.38 3.596h-3.502l4.097-6.001zm15.3 20.84v-30.52h-2.194v-0.732h3.035v31.98h-3.035v-0.732z"/>
- </g>
-</svg>
--- a/www/Octicons-bug.svg
+++ b/www/Octicons-bug.svg
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   height="800.3468"
-   width="733.88495"
-   version="1.1"
-   id="svg4"
-   sodipodi:docname="Octicons-bug.svg"
-   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs8" />
-  <sodipodi:namedview
-     id="namedview6"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     showgrid="false"
-     inkscape:zoom="0.85253906"
-     inkscape:cx="367.1386"
-     inkscape:cy="432.23826"
-     inkscape:window-width="3828"
-     inkscape:window-height="2081"
-     inkscape:window-x="0"
-     inkscape:window-y="46"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="svg4" />
-  <path
-     d="m 243.6206,76.877783 c -52.874,56.780997 -38.281,147.468997 -38.281,147.468997 0,0 53.968,64 160,64 106.031,0 160.031,-64 160.031,-64 0,0 14.375,-89.469 -37.375,-146.311997 32.375,-18.031 51.438,-44.094 43.562,-61.812 -8.938,-19.9689999 -48.375,-21.7499999 -88.25,-3.969 -14.812,6.594 -27.438,14.969 -37.25,23.875 -12.438,-2.25 -25.625,-3.781 -40.72,-3.781 -14.061,0 -26.561,1.344 -38.344,3.25 -9.656,-8.75 -22.062,-16.875 -36.531,-23.344 -39.875,-17.7189999 -79.375,-15.9379999 -88.25,3.969 -7.748,17.343 10.284,42.686 41.408,60.655 z m 401.125,413.218997 c -8.25,-1.75 -16.125,-2.75 -23.75,-3.5 0,-2.125 0.375,-4.125 0.375,-6.312 0,-33.594 -4.75,-65.654 -12.438,-96.125 16.438,1.406 37.375,-2.375 58.562,-11.779 39.875,-17.781 65,-48.375 56.125,-68.219 -8.875,-19.969 -48.375,-21.75 -88.25,-3.969 -18.625,8.312 -33.812,19.469 -44,30.906 -7.75,-18.25 -16.5,-35.781 -26.812,-51.719 -30.188,25.156 -87.312,62.719 -167.062,71.062 v 321.781 c 0,0 -0.25,32 -32.031,32 -31.75,0 -32,-32 -32,-32 v -321.657 c -79.811,-8.344 -136.968,-45.969 -167.093,-71.062 -9.875,15.312 -18.375,32 -25.938,49.344 -10.281,-10.625 -24.625,-20.844 -41.969,-28.594 -39.875,-17.719 -79.375,-15.938 -88.25,3.969 -8.9060001,19.906 16.25,50.438 56.125,68.219 19.844,8.846 39.531,12.812 55.469,12.096 -7.656,30.404 -12.469,62.344 -12.469,95.812 0,2.188 0.375,4.25 0.438,6.5 -6.719,0.75 -13.688,1.75 -20.781,3.25 -51.969,10.75 -91.7810001,37.625 -88.84400014,59.812 2.93800004,22.312 47.50000014,31.5 99.59400014,20.688 6.781,-1.375 13.438,-3.125 19.781,-5.062 9.156,40.809 23.812,78.684 44.094,111.309 -12.031,6.062 -24.531,15 -36.031,26.625 -31.876,31.875 -44.812,70.625 -28.876,86.563 15.938,15.937 54.656,3 86.531,-28.812 9.344,-9.375 16.844,-19.25 22.656,-29 43.532,42.624 98.063,68.124 157.563,68.124 60.343,0 115.781,-26.25 159.531,-69.938 5.875,10.312 13.75,20.812 23.625,30.688 31.812,31.875 70.625,44.812 86.562,28.875 15.937,-15.937 3,-54.625 -28.875,-86.5 -12.312,-12.375 -25.688,-21.75 -38.438,-27.938 20.125,-32.5 34.625,-70.375 43.688,-111.062 7.188,2.25 14.688,4.375 22.562,6.062 52.061,10.812 96.625,1.562 99.625,-20.688 2.813,-22.124 -36.999,-48.999 -88.999,-59.749 z"
-     id="path2" />
-</svg>
--- a/www/ghcup.css
+++ b/www/ghcup.css
@@ -174,17 +174,7 @@ span.code {
    line-height: 2rem;
 }

-#help {
-    margin-bottom: 0px !important;
-}
-
-#collective {
-    margin-top: 1em !important;
-    margin-bottom: 0px !important;
-}
-
 #about {
-    margin-top: 0.5em !important;
    font-size: 16px;
    line-height: 2em;
 }
--- a/www/index.html
+++ b/www/index.html
@@ -45,9 +45,9 @@
        <p>
            To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
 			<div>
-			<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-powershell">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 $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
+			<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-powershell">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</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
 			</div>
-				<p class="other-help">If you want to run a non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
+				<p class="other-help">If you want to run an interactive installation, change <span class='code'>$false</span> to <span class='code'>$true</span> at the end of the script.</p>
 			</div>
 		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
 		</p>
@@ -65,9 +65,9 @@
        <p>
            To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
 			<div>
-			<div class="command-button"><pre><span class='ghcup-command'>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 $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
+			<div class="command-button"><pre><span class='ghcup-command'>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</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
 			</div>
-				<p class="other-help">If you want to run an non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
+				<p class="other-help">If you want to run an interactive installation, change <span class='code'>$false</span> to <span class='code'>$true</span> at the end of the script.</p>
 			</div>
        </p>
 		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
@@ -128,27 +128,19 @@
        <div>
          <p>
            If you are running Windows,<br/>run the following in a powershell session (as a non-admin user).
-			<div class="command-button"><pre><span class='ghcup-command'>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 $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
-			</div>
-				<p class="other-help">If you want to run a non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
-			</div>
+			<div class="command-button"><pre><span class='ghcup-command'>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</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          </p>
        </div>

      </div>

-      <p id="help">
-	  Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup"><img src="irc.svg" height="18px" alt="" />IRC</a>, <a href="https://discord.gg/pKYf3zDQU7"><img src="Discord-Logo-Black.svg" height="18px" alt="" />Discord</a>, <a href="https://app.element.io/#/room/#haskell-tooling:matrix.org"><img src="Matrix_logo.svg" height="25px" alt="" style="top:5px;position:relative;" /></a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug <img src="Octicons-bug.svg" height="18px" alt="" /></a>.
-      </p>
-      <p id="collective">
-		<a id="collective" href="https://opencollective.com/ghcup#category-CONTRIBUTE" target="_blank">
-			<img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" width=200 />
-		</a>
+      <p>
+        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">
        <img src="haskell-logo.svg" alt="" />
-        ghcup is a haskell.org supported project.
+        ghcup is a haskell.org hosted project.
        <br/>
        <a href="https://www.haskell.org/downloads/">other installation options</a>
        &nbsp;&middot;&nbsp;
--- a/www/irc.svg
+++ b/www/irc.svg
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   height="18.043058"
-   viewBox="0 0 18 18.043058"
-   width="18"
-   version="1.1"
-   id="svg4"
-   sodipodi:docname="irc.svg"
-   inkscape:version="1.1 (c68e22c387, 2021-05-23)"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs8" />
-  <sodipodi:namedview
-     id="namedview6"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     showgrid="false"
-     inkscape:zoom="36.375"
-     inkscape:cx="3.3814433"
-     inkscape:cy="9.0309278"
-     inkscape:window-width="3828"
-     inkscape:window-height="2081"
-     inkscape:window-x="0"
-     inkscape:window-y="46"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="svg4" />
-  <path
-     class="heroicon-ui"
-     d="m 8.03,5.0375961 h 3.94 l 1.06,-4.23999995 a 1,1 0 1 1 1.94,0.47999995 l -0.94,3.76 H 17 a 1,1 0 0 1 0,2 h -3.47 l -1,3.9999999 H 15 a 1,1 0 1 1 0,2 h -2.97 l -1.06,4.25 a 1.0004624,1.0004624 0 1 1 -1.94,-0.49 l 0.94,-3.76 H 6.03 l -1.06,4.25 a 1.0004624,1.0004624 0 1 1 -1.94,-0.49 l 0.94,-3.76 H 1 a 1,1 0 0 1 0,-2 h 3.47 l 1,-3.9999999 H 3 a 1,1 0 0 1 0,-2 H 5.97 L 7.03,0.79759615 A 1,1 0 1 1 8.97,1.2775961 Z m -0.5,2 -1,3.9999999 h 3.94 l 1,-3.9999999 z"
-     id="path2" />
-</svg>