Add better support for pyproject.toml pixi projects (#87 )

Co-authored-by: Pavel Zwerschke <pavelzw@gmail.com>
support preinstalled local pixi (#98 )
2026-10-06 10:01:54 +03:00 · 2024-04-16 14:31:30 +02:00 · 2024-04-15 09:37:12 +02:00 · 2024-04-11 15:28:58 +02:00 · 2024-04-11 14:32:36 +02:00 · 2024-04-08 08:33:42 +02:00
37 changed files with 44722 additions and 3158 deletions
@@ -0,0 +1,3 @@
+If updating documentation:
+
+- [ ] Updated documentation in https://github.com/prefix-dev/pixi/blob/main/docs/advanced/github_actions.md as well
@@ -3,14 +3,16 @@ updates:
  - package-ecosystem: github-actions
    directory: /
    schedule:
-      interval: weekly
+      interval: monthly
+    groups:
+      dependencies:
+        patterns:
+          - "*"
  - package-ecosystem: npm
    directory: /
    schedule:
-      interval: weekly
+      interval: monthly
    groups:
-      dev-dependencies:
+      dependencies:
        patterns:
-          - "*eslint*"
-          - "@types/*"
-          - "prettier"
+          - "*"
@@ -3,21 +3,24 @@ changelog:
    labels:
      - ignore for release
  categories:
-    - title: New features
+    - title: 💥 Breaking changes
+      labels:
+        - breaking
+    - title: ✨ New features
      labels:
        - enhancement
-    - title: CI
+    - title: 👷🏻 CI
      labels:
        - ci
-    - title: Bug fixes
+    - title: 🐛 Bug fixes
      labels:
        - bug
-    - title: Documentation
+    - title: 📝 Documentation
      labels:
        - documentation
-    - title: Dependency updates
+    - title: ⬆️ Dependency updates
      labels:
        - dependencies
-    - title: Other changes
+    - title: 🤷🏻 Other changes
      labels:
        - "*"
@@ -6,20 +6,22 @@ on:
  pull_request:
    branches: [main]
  merge_group:
+  schedule:
+    - cron: 0 6 * * MON

 jobs:
  build:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4

      - name: Install pnpm
-        uses: pnpm/action-setup@v2
+        uses: pnpm/action-setup@v3
        with:
          version: 8

      - name: Install Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: pnpm
@@ -29,6 +31,93 @@ jobs:

      - name: Rebuild the dist/ directory
        run: pnpm build
-      
+
      - name: Lint
        run: pnpm lint
+
+  reference-latest-version-in-readme:
+    name: Reference latest version in README
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Assert latest setup-pixi version is mentioned in README
+        run: |
+          set -euo pipefail
+          latest_version="$(jq -r '.version' package.json)"
+          count_expected=13
+          count_actual="$(grep -c "setup-pixi@v$latest_version" README.md || true)"
+          if [ "$count_actual" -ne "$count_expected" ]; then
+            echo "::error file=README.md::Expected $count_expected mentions of \`setup-pixi@v$latest_version\` in README.md, but found $count_actual."
+            exit 1
+          fi
+
+  reference-latest-pixi-version-in-readme:
+    name: Reference latest Pixi version in README
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Assert latest pixi version is mentioned in README
+        run: |
+          set -euo pipefail
+          latest_version="$(gh repo view --json latestRelease prefix-dev/pixi | jq -r '.latestRelease.tagName')"
+          count_expected=1
+          count_actual="$(grep -c "pixi-version: $latest_version" README.md || true)"
+          if [ "$count_actual" -ne "$count_expected" ]; then
+            echo "::error file=README.md::Expected $count_expected mentions of \`pixi-version: $latest_version\` in README.md, but found $count_actual."
+            sed -i "s/pixi-version: .*/pixi-version: $latest_version/" README.md
+            exit 1
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create pull request
+        uses: peter-evans/create-pull-request@70a41aba780001da0a30141984ae2a0c95d8704e
+        if: failure() && github.ref_name == 'main'
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: Reference latest Pixi version in README
+          title: Reference latest Pixi version in README
+          labels: documentation
+
+  check-dist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 8
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Rebuild the dist/ directory
+        run: pnpm build
+
+      - name: Compare the expected and actual dist/ directories
+        run: |
+          if [ "$(git diff --ignore-space-at-eol dist/* | wc -l)" -gt "0" ]; then
+            echo "Detected uncommitted changes after build.  See status below:"
+            git diff
+            exit 1
+          fi
+        id: diff
+
+      # If index.js or post.js are different than expected, upload the expected version as an artifact
+      - uses: actions/upload-artifact@v4
+        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
+        with:
+          name: dist
+          path: dist/
@@ -1,48 +0,0 @@
-name: Check dist
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-  merge_group:
-
-jobs:
-  check-dist:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v2
-        with:
-          version: 8
-
-      - name: Install Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          cache: pnpm
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Rebuild the dist/ directory
-        run: pnpm build
-
-      - name: Compare the expected and actual dist/ directories
-        run: |
-          if [ "$(git diff --ignore-space-at-eol dist/* | wc -l)" -gt "0" ]; then
-            echo "Detected uncommitted changes after build.  See status below:"
-            git diff
-            exit 1
-          fi
-        id: diff
-
-      # If index.js or post.js are different than expected, upload the expected version as an artifact
-      - uses: actions/upload-artifact@v3
-        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
-        with:
-          name: dist
-          path: dist/
@@ -12,8 +12,8 @@ jobs:
  release:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: Quantco/ui-actions/version-metadata@v1
+      - uses: actions/checkout@v4
+      - uses: Quantco/ui-actions/version-metadata@a0653e9fc0ee3c4be9f7cc88e509e40536e9f3c1
        id: version-metadata
        with:
          file: ./package.json
@@ -24,7 +24,7 @@ jobs:
          TAG_NAME: v${{ steps.version-metadata.outputs.newVersion }}
      - name: Create release
        if: steps.version-metadata.outputs.changed == 'true'
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@9d7c94cfd0a1f3ed45544c887983e9fa900f0564
        with:
          generate_release_notes: true
          tag_name: v${{ steps.version-metadata.outputs.newVersion }}
@@ -9,63 +9,42 @@ on:

 jobs:
  default:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Move pixi.toml
-        run: mv test/default/* .
-      - uses: ./
-      - run: |
-          pixi info
-          test -f .pixi/env/bin/python
-          ./.pixi/env/bin/python --version | grep -q 3.11
-
-  no-run-install:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Move pixi.toml
-        run: mv test/default/* .
-      - uses: ./
-        with:
-          run-install: false
-      - run: |
-          ! test -d .pixi
-
-  custom-pixi-version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Move pixi.toml
-        run: mv test/default/* .
-      - uses: ./
-        with:
-          pixi-version: v0.1.0
-      - run: pixi --version | grep -q "pixi 0.1.0"
-
-  custom-pixi-url:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Move pixi.toml
-        run: mv test/default/* .
-      - uses: ./
-        with:
-          pixi-url: https://github.com/prefix-dev/pixi/releases/download/v0.0.8/pixi-x86_64-unknown-linux-musl
-      - run: pixi --version | grep -q "pixi 0.0.8"
-  
-  custom-manifest-path:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./
-        with:
-          manifest-path: test/default/pixi.toml
-  
-  different-log-level:
    strategy:
      matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+        cache: [true, false]
+    runs-on: ${{ matrix.os }}
+    name: default ${{ matrix.cache == true && 'with' || 'without' }} cache (${{ matrix.os }})
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        # check the action logs to see if the cache was used or not
+        with:
+          cache: ${{ matrix.cache }}
+      - run: |
+          set -o pipefail
+          pixi info
+          test -f .pixi/envs/default/bin/python
+          ./.pixi/envs/default/bin/python --version | grep -q 3.11
+        shell: bash
+        if: matrix.os != 'windows-latest'
+      - run: |
+          set -o pipefail
+          pixi info
+          test -f .pixi/envs/default/python.exe
+          ./.pixi/envs/default/python.exe --version | grep -q 3.11
+        shell: bash
+        if: matrix.os == 'windows-latest'
+      - run: |
+          pixi run python --version | grep -q 3.11
+          pixi run test | grep -q "Hello world"
+
+  no-run-install:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
@@ -73,49 +52,324 @@ jobs:
        run: mv test/default/* .
      - uses: ./
        with:
-          log-level: debug
+          run-install: false
+          cache: false
+      - run: |
+          ! test -d .pixi
+        shell: bash

-  # run-shell:
-  #   strategy:
-  #     matrix:
-  #       os: [ubuntu-latest, macos-latest]
-  #   runs-on: ${{ matrix.os }}
-  #   steps:
-  #   - uses: actions/checkout@v4
-  #   - name: Move pixi.toml
-  #     run: mv test/default/* .
-  #   - uses: ./
-  #     with:
-  #       generate-run-shell: true
-  #   - run: python --version | grep -q "3.11"
-  #     shell: pixi-shell {0}
-
-  custom-bin-path:
-    runs-on: ubuntu-latest
+  no-pixi-toml:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
    steps:
-    - uses: actions/checkout@v4
-    - name: Move pixi.toml
-      run: mv test/default/* .
-    - name: Create bin directory
-      run: mkdir bin
-    - uses: ./
-      with:
-        pixi-bin-path: bin/pixi
-    - run: |
-        which pixi | grep -q "..."
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          run-install: false
+      - run: |
+          ! test -d .pixi
+        shell: bash
+      - run: pixi info

-  auth-token:
-    runs-on: windows-latest
+  custom-pixi-version:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/old-pixi-lockfiles/* .
+      - uses: ./
+        with:
+          cache: false
+          pixi-version: v0.1.0
+          # pixi 0.1.0 doesn't support --locked
+          locked: false
+      - run: pixi --version | grep -q "pixi 0.1.0"
+
+  old-lockfile:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        locked: [true, false]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/old-pixi-lockfiles/* .
+      - uses: ./
+        with:
+          pixi-version: latest
+          cache: false
+          locked: ${{ matrix.locked }}
+      - if: matrix.os == 'windows-latest'
+        run: choco install yq
+      # assert that the lockfile wasn't updated
+      - run: test "$(yq '.version' pixi.lock)" = 1
+
+  install-path:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          run-install: false
+      - run: test "$(which pixi)" = "$HOME/.pixi/bin/pixi"
+        shell: bash
+
+  global-install:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          run-install: false
+      - run: pixi global install cowpy
+      - run: |
+          pixi global list 2>&1 | grep cowpy
+          cowpy hello world
+          test "$(which cowpy)" = "$HOME/.pixi/bin/cowpy"
+        if: matrix.os != 'windows-latest'
+      - run: cowpy hello world
+        if: matrix.os == 'windows-latest'
+
+  frozen:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Move pixi.toml
        run: mv test/default/* .
      - uses: ./
        with:
-          auth-host: TODO
-          auth-token: TODO
-      # TODO
-      # - run:
+          cache: false
+          frozen: true
+      - run: pixi run python --version | grep -q 3.11
+
+  locked:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: false
+          locked: true
+      - run: pixi run python --version | grep -q 3.11
+
+  custom-pixi-url:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/old-pixi-lockfiles/* .
+      - uses: ./
+        with:
+          cache: false
+          pixi-url: https://github.com/prefix-dev/pixi/releases/download/v0.14.0/pixi-x86_64-unknown-linux-musl
+      - run: pixi --version | grep -q "pixi 0.14.0"
+
+  custom-manifest-path:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          cache: false
+          manifest-path: test/default/pixi.toml
+
+  different-log-level:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: false
+          log-level: v
+
+  custom-bin-path:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Move pixi.toml
+      run: mv test/default/* .
+    - uses: ./
+      with:
+        cache: false
+        pixi-bin-path: custom-bin/pixi${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+    - run: |
+        test -f custom-bin/pixi${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+        pixi --help
+        which pixi | grep -q custom-bin/pixi
+        # which pixi should be absolute
+        which pixi | grep -q "^/"
+
+  existing-pixi-bin:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        ignore-reason: [ none, version, version-latest, url, bin-path]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - name: Create pixi directory and add to PATH
+        run: |
+          mkdir -p $HOME/custom-existing-pixi
+          echo $HOME/custom-existing-pixi >> $GITHUB_PATH
+        if: matrix.os != 'windows-latest'
+      - name: Create pixi directory and add to PATH (Windows)
+        run: |
+          mkdir $env:USERPROFILE\custom-existing-pixi
+          echo $env:USERPROFILE\custom-existing-pixi >> $env:GITHUB_PATH
+        shell: pwsh
+        if: matrix.os == 'windows-latest'
+      - name: Download pixi binary (Ubuntu)
+        run: |
+          set -o pipefail
+          curl -L --output $HOME/custom-existing-pixi/pixi https://github.com/prefix-dev/pixi/releases/download/v0.14.0/pixi-x86_64-unknown-linux-musl
+          chmod +x $HOME/custom-existing-pixi/pixi
+        if: matrix.os == 'ubuntu-latest'
+      - name: Download pixi binary (macOS)
+        run: |
+          set -o pipefail
+          curl -L --output $HOME/custom-existing-pixi/pixi https://github.com/prefix-dev/pixi/releases/download/v0.14.0/pixi-x86_64-apple-darwin
+          chmod +x $HOME/custom-existing-pixi/pixi
+        if: matrix.os == 'macos-latest'
+      - name: Download pixi binary (Windows)
+        run: |
+          curl -L --output $HOME/custom-existing-pixi/pixi.exe https://github.com/prefix-dev/pixi/releases/download/v0.14.0/pixi-x86_64-pc-windows-msvc.exe
+        if: matrix.os == 'windows-latest'
+      - run: |
+          echo "Path: $PATH"
+        shell: bash
+      - name: Verify pixi version (before setup-pixi)
+        run: |
+          pixi --version
+          pixi --version | grep -q "pixi 0.14.0"
+        shell: bash
+      - name: Verify pixi path (before setup-pixi)
+        run: |
+          which pixi | grep -q $HOME/custom-existing-pixi/pixi
+        shell: bash
+      - name: Run Action (should use preinstalled pixi)
+        uses: ./
+        with:
+          cache: false
+        if: matrix.ignore-reason == 'none'
+      - name: Run Action (version-latest should overwrite preinstalled pixi)
+        uses: ./
+        with:
+          cache: false
+          pixi-version: latest
+        if: matrix.ignore-reason == 'version-latest'
+      - name: Run Action (version should overwrite preinstalled pixi)
+        uses: ./
+        with:
+          cache: false
+          pixi-version: v0.16.0
+        if: matrix.ignore-reason == 'version'
+      - name: Run Action (url should overwrite preinstalled pixi)
+        uses: ./
+        with:
+          cache: false
+          pixi-url: |
+            ${{
+                matrix.os == 'ubuntu-latest' &&
+                    'https://github.com/prefix-dev/pixi/releases/download/v0.16.0/pixi-x86_64-unknown-linux-musl'
+                || matrix.os == 'macos-latest' &&
+                    'https://github.com/prefix-dev/pixi/releases/download/v0.16.0/pixi-x86_64-apple-darwin'
+                || 'https://github.com/prefix-dev/pixi/releases/download/v0.16.0/pixi-x86_64-pc-windows-msvc.exe'
+            }}
+        if: matrix.ignore-reason == 'url'
+      - name: Create custom bin directory
+        run: mkdir custom-bin
+        shell: bash
+        if: matrix.ignore-reason == 'bin-path'
+      - name: Run Action (pixi-bin-path should overwrite preinstalled pixi)
+        uses: ./
+        with:
+          cache: false
+          # this will implicitly set pixi-version to latest
+          pixi-bin-path: custom-bin/pixi${{ matrix.os == 'windows-latest' && '.exe' || '' }}
+        if: matrix.ignore-reason == 'bin-path'
+      - name: Verify pixi version (after setup-pixi) - still at 0.14.0
+        run: |
+          pixi --version
+          pixi --version | grep -q 0.14.0
+        shell: bash
+        if: matrix.ignore-reason == 'none'
+      - name: Verify pixi version (after setup-pixi) - should be 0.16.0
+        run: |
+          pixi --version
+          pixi --version | grep -q 0.16.0
+        shell: bash
+        if: matrix.ignore-reason != 'none' && matrix.ignore-reason != 'bin-path' && matrix.ignore-reason != 'version-latest'
+      - name: Verify pixi version (after setup-pixi) - should be latest
+        run: |
+          pixi --version
+          pixi --version | grep -vq 0.14.0
+          pixi --version | grep -vq 0.16.0
+        shell: bash
+        if: matrix.ignore-reason == 'bin-path' || matrix.ignore-reason == 'version-latest'
+      - name: Verify pixi path (after setup-pixi, no ignore reason)
+        run: |
+          which pixi | grep -q $HOME/custom-existing-pixi/pixi
+        shell: bash
+        if: matrix.ignore-reason == 'none'
+      - name: Verify pixi path (after setup-pixi, ignore reason)
+        run: |
+          which pixi | grep -vq $HOME/custom-existing-pixi/pixi
+        shell: bash
+        if: matrix.ignore-reason != 'none'
+
+  auth-token:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: false
+          auth-host: https://custom-conda-registry.com
+          auth-token: custom-token
+      - run: |
+          cat ~/.rattler/credentials.json
+          [ $(jq '."*.custom-conda-registry.com".BearerToken' -r ~/.rattler/credentials.json) = "custom-token" ]
+        # all other platforms have the credentials stored in the keychain
+        # https://github.com/prefix-dev/pixi/issues/330
+        if: matrix.os == 'ubuntu-latest'

  auth-username-password:
    strategy:
@@ -128,41 +382,85 @@ jobs:
        run: mv test/default/* .
      - uses: ./
        with:
-          auth-host: TODO
-          auth-username: TODO
-          auth-password: TODO
+          cache: false
+          auth-host: https://custom-conda-registry.com
+          auth-username: custom-username
+          auth-password: custom-password
+      - run: |
+          cat ~/.rattler/credentials.json
+          [ $(jq '."*.custom-conda-registry.com".BasicHTTP.username' -r ~/.rattler/credentials.json) = "custom-username" ]
+          [ $(jq '."*.custom-conda-registry.com".BasicHTTP.password' -r ~/.rattler/credentials.json) = "custom-password" ]
+        # all other platforms have the credentials stored in the keychain
+        # https://github.com/prefix-dev/pixi/issues/330
+        if: matrix.os == 'ubuntu-latest'

  auth-conda-token:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Move pixi.toml
        run: mv test/default/* .
      - uses: ./
        with:
-          auth-host: TODO
-          auth-conda-token: TODO
+          cache: false
+          auth-host: https://custom-conda-registry.com
+          auth-conda-token: custom-conda-token
+      - run: |
+          cat ~/.rattler/credentials.json
+          [ $(jq '."*.custom-conda-registry.com".CondaToken' -r ~/.rattler/credentials.json) = "custom-conda-token" ]
+        # all other platforms have the credentials stored in the keychain
+        # https://github.com/prefix-dev/pixi/issues/330
+        if: matrix.os == 'ubuntu-latest'

-  post-cleanup:
-    # not implemented yet
-    if: false
-    name: post-cleanup ${{ matrix.post-cleanup }}
+  auth-token-install:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/auth/* .
+      - uses: ./
+        with:
+          cache: false
+          auth-host: https://repo.prefix.dev
+          auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
+      - name: Ensure private-package is installed
+        run: |
+          test -f .pixi/envs/default/conda-meta/private-package-0.0.1-0.json
+
+  pixi-shell:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: false
+      - run: |
+          python --version | grep -q "3.11"
+        shell: pixi run bash -e {0}
+      - run: |
+          import sys
+          print(sys.version)
+          print("Hello world")
+        shell: pixi run python {0}
+      - run: |
+          python --version | Select-String "3.11"
+        shell: pixi run pwsh -Command {0}
+  post-cleanup-linux:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        include:
-          - post-cleanup: 'none'
-            env-exists: ''
-            cache-exists: ''
-            pixi-dir-exists: ''
-          - post-cleanup: 'environment'
-            env-exists: '! '
-            cache-exists: ''
-            pixi-dir-exists: ''
-          - post-cleanup: 'all'
-            env-exists: '! '
-            cache-exists: '! '
-            pixi-dir-exists: '! '
+        post-cleanup: ['true', 'false']
    steps:
      - uses: actions/checkout@v4
      - name: Move pixi.toml
@@ -171,21 +469,366 @@ jobs:
        with:
          run: |
            set -euxo pipefail
-            ${{ matrix.env-exists }}test -d .pixi
-            ${{ matrix.cache-exists }}test -d ~/.cache/rattler
-            ${{ matrix.pixi-dir-exists }}test -f ~/.pixi
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d .pixi
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d ~/.rattler
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d ~/.cache/rattler
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -f ~/.pixi/bin/pixi
      - uses: ./
        with:
+          cache: false
          post-cleanup: ${{ matrix.post-cleanup }}
-    
-  no-lockfile:
+          # ~/.rattler is only created if the user has logged in
+          auth-host: https://custom-conda-registry.com
+          auth-token: custom-token
+
+  post-cleanup-linux-no-login:
    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        post-cleanup: ['true', 'false']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: lisanna-dettwyler/action-post-run@d053b9b43d788b87a409f6cdb3b6fc87c6c8a4fe
+        with:
+          run: |
+            set -euxo pipefail
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d .pixi
+            ! test -d ~/.rattler
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d ~/.cache/rattler
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -f ~/.pixi/bin/pixi
+      - uses: ./
+        with:
+          cache: false
+          post-cleanup: ${{ matrix.post-cleanup }}
+
+  post-cleanup-macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        post-cleanup: ['true', 'false']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: lisanna-dettwyler/action-post-run@d053b9b43d788b87a409f6cdb3b6fc87c6c8a4fe
+        with:
+          run: |
+            set -euxo pipefail
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d .pixi
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d ~/Library/Caches/rattler
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -f ~/.pixi/bin/pixi
+      - uses: ./
+        with:
+          cache: false
+          post-cleanup: ${{ matrix.post-cleanup }}
+
+  post-cleanup-windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        post-cleanup: ['true', 'false']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: lisanna-dettwyler/action-post-run@d053b9b43d788b87a409f6cdb3b6fc87c6c8a4fe
+        with:
+          run: |
+            set -euxo pipefail
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d .pixi
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -d "$LOCALAPPDATA/rattler"
+            ${{ matrix.post-cleanup == 'true' && '! ' || '' }}test -f ~/.pixi/bin/pixi
+      - uses: ./
+        with:
+          cache: false
+          post-cleanup: ${{ matrix.post-cleanup }}
+
+  no-lockfile:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Move pixi.toml
        run: mv test/no-lockfile/* .
      - uses: ./
+        with:
+          cache: false
      - run: |
+          set -o pipefail
          pixi info
-          test -f .pixi/env/bin/python
-          ./.pixi/env/bin/python --version | grep -q 3.11
+          test -f .pixi/envs/default/bin/python
+          ./.pixi/envs/default/bin/python --version | grep -q 3.11
+        shell: bash
+        if: matrix.os != 'windows-latest'
+      - run: |
+          set -o pipefail
+          pixi info
+          test -f .pixi/envs/default/python.exe
+          ./.pixi/envs/default/python.exe --version | grep -q 3.11
+        shell: bash
+        if: matrix.os == 'windows-latest'
+      - run: |
+          pixi run python --version | grep -q 3.11
+          pixi run test | grep -q "Hello world"
+
+  multiple-environments:
+    name: multiple-environments (${{ matrix.os }}, cache=${{ matrix.cache }})
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+        cache: ['true', 'false']
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/multiple-environments/* .
+      - uses: ./
+        with:
+          environments: py311 py312
+          cache: ${{ matrix.cache }}
+      - run: |
+          set -o pipefail
+          pixi info
+          test -f .pixi/envs/py311/bin/python
+          test -f .pixi/envs/py312/bin/python
+          ! test -d .pixi/envs/default
+          ./.pixi/envs/py311/bin/python --version | grep -q 3.11
+          ./.pixi/envs/py312/bin/python --version | grep -q 3.12
+        shell: bash
+        if: matrix.os != 'windows-latest'
+      - run: |
+          set -o pipefail
+          pixi info
+          test -f .pixi/envs/py311/python.exe
+          test -f .pixi/envs/py312/python.exe
+          ! test -d .pixi/envs/default
+          ./.pixi/envs/py311/python.exe --version | grep -q 3.11
+          ./.pixi/envs/py312/python.exe --version | grep -q 3.12
+        shell: bash
+        if: matrix.os == 'windows-latest'
+
+  cache-write-true:
+    timeout-minutes: 10
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-14]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi files
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache-write: true
+
+  test-cache1:
+    name: Test cache 1/2
+    timeout-minutes: 10
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-14]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi files
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: true
+          cache-key: test-cache-${{ github.sha }}-${{ github.run_attempt }}-
+      # check the action logs to see if the cache was written
+      - run: |
+          test -f .pixi/envs/default/bin/python
+        if: matrix.os != 'windows-latest'
+      - run: |
+          test -f .pixi/envs/default/python.exe
+        if: matrix.os == 'windows-latest'
+
+  test-cache2:
+    name: Test cache 2/2
+    timeout-minutes: 10
+    needs: test-cache1
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-14]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi files
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: true
+          cache-key: test-cache-${{ github.sha }}-${{ github.run_attempt }}-
+      # check the action logs to see if the cache was restored
+      - run: |
+          test -f .pixi/envs/default/bin/python
+        if: matrix.os != 'windows-latest'
+      - run: |
+          test -f .pixi/envs/default/python.exe
+        if: matrix.os == 'windows-latest'
+
+  test-cache-no-write:
+    name: Test cache no write
+    timeout-minutes: 10
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-14]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi files
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          cache: true
+          cache-write: false
+          cache-key: test-cache-${{ github.sha }}-${{ github.run_attempt }}-
+      # check the action logs to see if the cache write was skipped
+  
+  pyproject:
+    timeout-minutes: 10
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi files
+        run: mv test/pyproject-manifest/* .
+      - uses: ./
+      - run: test -f .pixi/envs/default/bin/python
+      - run: pixi run test
+
+  custom-pyproject-manifest-path:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          cache: true
+          manifest-path: test/pyproject-manifest/pyproject.toml
+
+  # not properly testable
+  # https://github.com/actions/runner/issues/2347
+  # https://github.com/orgs/community/discussions/15452
+  # test-cache-fail-no-lockfile:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/no-lockfile/* .
+  #     - uses: ./
+  #       with:
+  #         cache: true
+  #         cache-key: test-cache-no-lockfile-${{ github.sha }}-${{ github.run_attempt }}-
+  #     - run: exit 1
+  #       if: success()
+
+  # test-incorrect-version:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/default/* .
+  #     - uses: ./
+  #       with:
+  #         pixi-version: 0.1.0
+  #     - run: exit 1
+  #       if: success()
+
+  # test-frozen-and-locked:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/default/* .
+  #     - uses: ./
+  #       with:
+  #         pixi-version: v0.5.0
+  #         frozen: true
+  #         locked: true
+  #     - run: exit 1
+  #       if: success()
+
+  # test-frozen-no-lockfile:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/no-lockfile/* .
+  #     - uses: ./
+  #       with:
+  #         frozen: true
+  #     - run: exit 1
+  #       if: success()
+
+  # test-locked-no-lockfile:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/no-lockfile/* .
+  #     - uses: ./
+  #       with:
+  #         locked: true
+  #     - run: exit 1
+  #       if: success()
+
+  # test-lockfile-not-up-to-date:
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/lockfile-not-up-to-date/* .
+  #     - uses: ./
+  #       # locked: true is implicit
+  #     - run: exit 1
+  #       if: success()
+
+  # cache-write-true-no-lockfile:
+  #   timeout-minutes: 10
+  #   runs-on: ${{ matrix.os }}
+  #   strategy:
+  #     fail-fast: false
+  #     matrix:
+  #       os: [windows-latest, ubuntu-latest, macos-latest]
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - name: Move pixi files
+  #       run: mv test/no-lockfile/* .
+  #     - uses: ./
+  #       with:
+  #         cache-write: true
@@ -97,3 +97,6 @@ Thumbs.db
 # Ignore built ts files
 __tests__/runner/*
 lib/**/*
+
+# Ignore jetbrains files
+.idea
@@ -0,0 +1,330 @@
+<h1 align="center">
+
+[![License][license-badge]][license]
+[![CI][build-badge]][build]
+[![Latest release][latest-release-badge]][releases]
+[![Project Chat][chat-badge]][chat-url]
+
+[license-badge]: https://img.shields.io/github/license/prefix-dev/setup-pixi?style=flat-square
+[license]: ./LICENSE
+[build-badge]: https://img.shields.io/github/actions/workflow/status/prefix-dev/setup-pixi/test.yml?style=flat-square
+[build]: https://github.com/prefix-dev/setup-pixi/actions/
+[latest-release-badge]: https://img.shields.io/github/v/tag/prefix-dev/setup-pixi?style=flat-square&label=latest&sort=semver
+[releases]: https://github.com/prefix-dev/setup-pixi/releases
+[chat-badge]: https://img.shields.io/discord/1082332781146800168.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2&style=flat-square
+[chat-url]: https://discord.gg/kKV8ZxyzY4
+
+</h1>
+
+# setup-pixi 📦
+
+GitHub Action to set up the [pixi](https://github.com/prefix-dev/pixi) package manager.
+
+## Usage
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    pixi-version: v0.19.1
+    cache: true
+    auth-host: prefix.dev
+    auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
+- run: pixi run test
+```
+
+> [!WARNING]
+> Since pixi is not yet stable, the API of this action may change between minor versions.
+> Please pin the versions of this action to a specific version (i.e., `prefix-dev/setup-pixi@v0.6.0`) to avoid breaking changes.
+> You can automatically update the version of this action by using [Dependabot](https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot).
+>
+> Put the following in your `.github/dependabot.yml` file to enable Dependabot for your GitHub Actions:
+>
+> ```yml
+> version: 2
+> updates:
+>   - package-ecosystem: github-actions
+>     directory: /
+>     schedule:
+>       interval: monthly # or daily, weekly
+>     groups:
+>       dependencies:
+>         patterns:
+>           - "*"
+> ```
+
+## Features
+
+To see all available input arguments, see the [`action.yml`](action.yml) file.
+
+### Caching
+
+The action supports caching of the pixi environment.
+By default, caching is enabled if a `pixi.lock` file is present.
+It will then use the `pixi.lock` file to generate a hash of the environment and cache it.
+If the cache is hit, the action will skip the installation and use the cached environment.
+You can specify the behavior by setting the `cache` input argument.
+
+If you need to customize your cache-key, you can use the `cache-key` input argument.
+This will be the prefix of the cache key. The full cache key will be `<cache-key><conda-arch>-<hash>`.
+
+#### Only save caches on `main`
+
+In order to not exceed the [10 GB cache size limit](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy) as fast, you might want to restrict when the cache is saved.
+This can be done by setting the `cache-write` argument.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    cache: true
+    cache-write: ${{ github.event_name == 'push' && github.ref_name == 'main' }}
+```
+
+### Multiple environments
+
+With pixi, you can create multiple environments for different requirements.
+You can also specify which environment(s) you want to install by setting the `environments` input argument.
+This will install all environments that are specified and cache them.
+
+```toml
+[project]
+name = "my-package"
+channels = ["conda-forge"]
+platforms = ["linux-64"]
+
+[dependencies]
+python = ">=3.11"
+pip = "*"
+polars = ">=0.14.24,<0.21"
+
+[feature.py311.dependencies]
+python = "3.11.*"
+[feature.py312.dependencies]
+python = "3.12.*"
+
+[environments]
+py311 = ["py311"]
+py312 = ["py312"]
+```
+
+#### Multiple environments using a matrix
+
+The following example will install the `py311` and `py312` environments in different jobs.
+
+```yml
+test:
+  runs-on: ubuntu-latest
+  strategy:
+    matrix:
+      environment: [py311, py312]
+  steps:
+  - uses: actions/checkout@v4
+  - uses: prefix-dev/setup-pixi@v0.6.0
+    with:
+      environments: ${{ matrix.environment }}
+```
+
+#### Install multiple environments in one job
+
+The following example will install both the `py311` and the `py312` environment on the runner.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    # separated by spaces
+    environments: >-
+      py311
+      py312
+- run: |
+    pixi run -e py311 test
+    pixi run -e py312 test
+```
+
+> [!WARNING]
+> If you don't specify any environment, the `default` environment will be installed and cached, even if you use other environments.
+
+### Authentication
+
+There are currently three ways to authenticate with pixi:
+
+- using a token
+- using a username and password
+- using a conda-token
+
+For more information, see the [pixi documentation](https://prefix.dev/docs/pixi/authentication).
+
+> [!WARNING]
+> Please only store sensitive information using [GitHub secrets](https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions). Do not store them in your repository.
+> When your sensitive information is stored in a GitHub secret, you can access it using the `${{ secrets.SECRET_NAME }}` syntax.
+> These secrets will always be masked in the logs.
+
+#### Token
+
+Specify the token using the `auth-token` input argument.
+This form of authentication (bearer token in the request headers) is mainly used at [prefix.dev](https://prefix.dev).
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    auth-host: prefix.dev
+    auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
+```
+
+#### Username and password
+
+Specify the username and password using the `auth-username` and `auth-password` input arguments.
+This form of authentication (HTTP Basic Auth) is used in some enterprise environments with [artifactory](https://jfrog.com/artifactory) for example.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    auth-host: custom-artifactory.com
+    auth-username: ${{ secrets.PIXI_USERNAME }}
+    auth-password: ${{ secrets.PIXI_PASSWORD }}
+```
+
+#### Conda-token
+
+Specify the conda-token using the `conda-token` input argument.
+This form of authentication (token is encoded in URL: `https://my-quetz-instance.com/t/<token>/get/custom-channel`) is used at [anaconda.org](https://anaconda.org) or with [quetz instances](https://github.com/mamba-org/quetz).
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    auth-host: anaconda.org # or my-quetz-instance.com
+    conda-token: ${{ secrets.CONDA_TOKEN }}
+```
+
+### Custom shell wrapper
+
+`setup-pixi` allows you to run command inside of the pixi environment by specifying a custom shell wrapper with `shell: pixi run bash -e {0}`.
+This can be useful if you want to run commands inside of the pixi environment, but don't want to use the `pixi run` command for each command.
+
+```yml
+- run: | # everything here will be run inside of the pixi environment
+    python --version
+    pip install -e --no-deps .
+  shell: pixi run bash -e {0}
+```
+
+You can even run Python scripts like this:
+
+```yml
+- run: | # everything here will be run inside of the pixi environment
+    import my_package
+    print("Hello world!")
+  shell: pixi run python {0}
+```
+
+If you want to use PowerShell, you need to specify `-Command` as well.
+```yml
+- run: | # everything here will be run inside of the pixi environment
+    python --version | Select-String "3.11"
+  shell: pixi run pwsh -Command {0} # pwsh works on all platforms
+```
+
+> [!NOTE]
+> Under the hood, the `shell: xyz {0}` option is implemented by creating a temporary script file and calling `xyz` with that script file as an argument.
+> This file does not have the executable bit set, so you cannot use `shell: pixi run {0}` directly but instead have to use `shell: pixi run bash {0}`.
+> There are some custom shells provided by GitHub that have slightly different behavior, see [`jobs.<job_id>.steps[*].shell`](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsshell) in the documentation.
+> See the [official documentation](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#custom-shell) and [ADR 0277](https://github.com/actions/runner/blob/main/docs/adrs/0277-run-action-shell-options.md) for more information about how the `shell:` input works in GitHub Actions.
+
+### `--frozen` and `--locked`
+
+You can specify whether `setup-pixi` should run `pixi install --frozen` or `pixi install --locked` depending on the `frozen` or the `locked` input argument.
+See the [official documentation](https://prefix.dev/docs/pixi/cli#install) for more information about the `--frozen` and `--locked` flags.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    locked: true
+    # or
+    frozen: true
+```
+
+If you don't specify anything, the default behavior is to run `pixi install --locked` if a `pixi.lock` file is present and `pixi install` otherwise.
+
+### Debugging
+
+There are two types of debug logging that you can enable.
+
+#### Debug logging of the action
+
+The first one is the debug logging of the action itself.
+This can be enabled by running the action with the `RUNNER_DEBUG` environment variable set to `true`.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  env:
+    RUNNER_DEBUG: true
+```
+
+Alternatively, you can enable debug logging for the action by re-running the action in debug mode:
+
+![Re-run in debug mode](.github/assets/enable-debug-logging-light.png#gh-light-mode-only)
+![Re-run in debug mode](.github/assets/enable-debug-logging-dark.png#gh-dark-mode-only)
+
+> For more information about debug logging in GitHub Actions, see [the official documentation](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging).
+
+#### Debug logging of pixi
+
+The second type is the debug logging of the pixi executable.
+This can be specified by setting the `log-level` input.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    # one of `q`, `default`, `v`, `vv`, or `vvv`.
+    log-level: vvv
+```
+
+If nothing is specified, `log-level` will default to `default` or `vv` depending on if [debug logging is enabled for the action](#debug-logging-of-the-action).
+
+### Self-hosted runners
+
+On self-hosted runners, it may happen that some files are persisted between jobs.
+This can lead to problems or secrets getting leaked between job runs.
+To avoid this, you can use the `post-cleanup` input to specify the post cleanup behavior of the action (i.e., what happens _after_ all your commands have been executed).
+
+If you set `post-cleanup` to `true`, the action will delete the following files:
+
+- `.pixi` environment
+- the pixi binary
+- the rattler cache
+- other rattler files in `~/.rattler`
+
+If nothing is specified, `post-cleanup` will default to `true`.
+
+On self-hosted runners, you also might want to alter the default pixi install location to a temporary location. You can use `pixi-bin-path: ${{ runner.temp }}/bin/pixi` to do this.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    post-cleanup: true
+    # ${{ runner.temp }}\Scripts\pixi.exe on Windows
+    pixi-bin-path: ${{ runner.temp }}/bin/pixi
+```
+
+You can also use a preinstalled local version of pixi on the runner by not setting any of the `pixi-version`,
+`pixi-url` or `pixi-bin-path` inputs. This action will then try to find a local version of pixi in the runner's PATH.
+
+### Using the `pyproject.toml` as a manifest file for pixi.
+
+`setup-pixi` will automatically pick up the `pyproject.toml` if it contains a `[tool.pixi.project]` section and no `pixi.toml`.
+This can be overwritten by setting the `manifest-path` input argument.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.6.0
+  with:
+    manifest-path: pyproject.toml
+```
+
+## More examples
+
+If you want to see more examples, you can take a look at the [GitHub Workflows of this repository](.github/workflows/test.yml).
+
+## Local Development
+
+1. Clone this repository.
+2. Run `pnpm install` inside the repository (if you don't have [`pnpm`](https://github.com/pnpm/pnpm) installed, you can install it with `pixi global install pnpm`).
+3. Run `pnpm dev` for live transpilation of the TypeScript source code. 
+4. To test the action, you can run [`act`](https://github.com/nektos/act) (inside docker) or use :sparkles: CI driven development :sparkles:.
@@ -13,20 +13,27 @@ inputs:
  log-level:
    description: |
      Log level for the pixi CLI.
-      One of `quiet`, `warn`, `info`, `debug`, or `trace`.
+      One of `q`, `default`, `v`, `vv`, or `vvv`.
  manifest-path:
    description: Path to the manifest file (i.e., `pixi.toml`) to use for the pixi CLI. Defaults to `pixi.toml`.
  run-install:
    description: Whether to run `pixi install` after setting up the environment. Defaults to `true`.
-  generate-run-shell:
+  environments:
    description: |
-      Whether to generate a custom shell script that allows to use it in the workflow file using `run: pixi-shell {0}`.
+      A space-separated list of environments to install. If not specified, only the default environment is installed.
+  locked:
+    description: Whether to use `pixi install --locked`. Defaults to `true` when the lockfile is present, otherwise `false`.
+  frozen:
+    description: Whether to use `pixi install --frozen`. Defaults to `false`.
  cache:
    description: Whether to cache the pixi environment. Defaults to `true`. Only works if `pixi.lock` is present.
  cache-key:
    description: |
      Cache key prefix to use for caching the pixi environment.
-      Defaults to `pixi-{conda-arch}`.
+      Defaults to `pixi-`. The full cache key is `<cache-key><conda-arch>-<sha-256-of-pixi-lock>`.
+  cache-write:
+    description: |
+      Whether to write to the cache or only read from it. Defaults to `true`.
  pixi-bin-path:
    description: |
      Path to the pixi binary to use. Defaults to `~/.pixi/bin/pixi`.
@@ -45,12 +52,8 @@ inputs:
    description: Conda token to use for authentication.
  post-cleanup:
    description: |
-      What kind of cleanup the action should do in the post step.
-      One of `none`, `environment` or `all`.
-      If `none`, no cleanup is done.
-      If `environment`, the pixi environment is removed.
-      If `all`, the pixi environment, the pixi CLI are removed and the rattler cache is cleared.
-      Defaults to `all`.
+      If the action should clean up after itself. Defaults to `true`.
+      If `true`, the pixi environment, the pixi binary and the rattler files in ~/.rattler and ~/.cache/rattler are removed.

 runs:
  using: node20
@@ -1,12 +1,13 @@
 {
  "name": "setup-pixi",
-  "version": "0.1.1",
+  "version": "0.6.0",
  "private": true,
  "description": "Action to set up the pixi package manager.",
  "scripts": {
    "build": "tsup",
    "dev": "tsup --watch",
-    "lint": "eslint ./src --ext ts"
+    "lint": "eslint ./src --ext ts",
+    "lint:fix": "eslint ./src --ext ts --fix"
  },
  "repository": {
    "type": "git",
@@ -20,27 +21,30 @@
  "author": "Pavel Zwerschke <pavelzw@gmail.com>",
  "license": "BSD-3-Clause",
  "dependencies": {
-    "@actions/cache": "^3.2.2",
-    "@actions/core": "^1.10.0",
+    "@actions/cache": "^3.2.4",
+    "@actions/core": "^1.10.1",
    "@actions/exec": "^1.1.1",
    "@actions/io": "^1.1.3",
    "@actions/tool-cache": "^2.0.1",
+    "toml": "^3.0.0",
    "untildify": "^5.0.0",
-    "zod": "^3.22.2"
+    "which": "^4.0.0",
+    "zod": "^3.22.4"
  },
  "devDependencies": {
-    "@types/node": "^20.5.9",
-    "@typescript-eslint/eslint-plugin": "^6.5.0",
-    "@typescript-eslint/parser": "^6.5.0",
-    "eslint": "^8.48.0",
-    "eslint-config-prettier": "^9.0.0",
+    "@types/node": "^20.12.2",
+    "@types/which": "^3.0.3",
+    "@typescript-eslint/eslint-plugin": "^7.4.0",
+    "@typescript-eslint/parser": "^7.4.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-n": "^16.0.2",
-    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-prettier": "^5.1.3",
    "eslint-plugin-promise": "^6.1.1",
-    "prettier": "^3.0.3",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2"
+    "prettier": "^3.2.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.3"
  }
 }
@@ -3,31 +3,50 @@ import path from 'path'
 import * as core from '@actions/core'
 import * as cache from '@actions/cache'
 import { options } from './options'
-import { sha256 } from './util'
+import { getCondaArch, sha256 } from './util'

 export const generateCacheKey = async (cacheKeyPrefix: string) =>
-  fs
-    .readFile(options.pixiLockFile, 'utf-8')
-    .then((content) => `${cacheKeyPrefix}${sha256(content)}`)
+  Promise.all([fs.readFile(options.pixiLockFile), fs.readFile(options.pixiBinPath)])
+    .then(([lockfileContent, pixiBinary]) => {
+      const lockfileSha = sha256(lockfileContent)
+      core.debug(`lockfileSha: ${lockfileSha}`)
+      const pixiSha = sha256(pixiBinary)
+      core.debug(`pixiSha: ${pixiSha}`)
+      // the path to the lock file decides where the pixi env is created (../.pixi/env)
+      // since conda envs are not relocatable, we need to include the path in the cache key
+      const lockfilePathSha = sha256(options.pixiLockFile)
+      core.debug(`lockfilePathSha: ${lockfilePathSha}`)
+      const environments = sha256(options.environments?.join(' ') ?? '')
+      core.debug(`environments: ${environments}`)
+      // since the lockfile path is not necessarily absolute, we need to include the cwd in the cache key
+      const cwdSha = sha256(process.cwd())
+      core.debug(`cwdSha: ${cwdSha}`)
+      const sha = sha256(lockfileSha + environments + pixiSha + lockfilePathSha + cwdSha)
+      core.debug(`sha: ${sha}`)
+      return `${cacheKeyPrefix}${getCondaArch()}-${sha}`
+    })
    .catch((err) => {
      throw new Error(`Failed to generate cache key: ${err}`)
    })

-const cachePath = path.join(path.basename(options.manifestPath), '.pixi')
+const cachePath = path.join(path.dirname(options.pixiLockFile), '.pixi')
+
+let cacheHit = false

 export const tryRestoreCache = (): Promise<string | undefined> => {
-  const cacheKeyPrefix = options.cacheKey
-  if (!cacheKeyPrefix) {
+  const cache_ = options.cache
+  if (!cache_) {
    core.debug('Skipping pixi cache restore.')
    return Promise.resolve(undefined)
  }
  return core.group('Restoring pixi cache', () =>
-    generateCacheKey(cacheKeyPrefix).then((cacheKey) => {
+    generateCacheKey(cache_.cacheKeyPrefix).then((cacheKey) => {
      core.debug(`Cache key: ${cacheKey}`)
      core.debug(`Cache path: ${cachePath}`)
      return cache.restoreCache([cachePath], cacheKey, undefined, undefined, false).then((key) => {
        if (key) {
          core.info(`Restored cache with key \`${key}\``)
+          cacheHit = true
        } else {
          core.info(`Cache miss`)
        }
@@ -38,13 +57,17 @@ export const tryRestoreCache = (): Promise<string | undefined> => {
 }

 export const saveCache = () => {
-  const cacheKeyPrefix = options.cacheKey
-  if (!cacheKeyPrefix) {
+  const cache_ = options.cache
+  if (!cache_ || !cache_.cacheWrite) {
    core.debug('Skipping pixi cache save.')
    return Promise.resolve(undefined)
  }
+  if (cacheHit) {
+    core.debug('Skipping pixi cache save because cache was restored.')
+    return Promise.resolve(undefined)
+  }
  return core.group('Saving pixi cache', () =>
-    generateCacheKey(cacheKeyPrefix).then((cacheKey) =>
+    generateCacheKey(cache_.cacheKeyPrefix).then((cacheKey) =>
      cache
        .saveCache([cachePath], cacheKey, undefined, false)
        .then((cacheId) => {
@@ -1,10 +1,11 @@
 import fs from 'fs/promises'
 import os from 'os'
 import path from 'path'
+import { exit } from 'process'
 import * as core from '@actions/core'
 import { downloadTool } from '@actions/tool-cache'
 import type { PixiSource } from './options'
-import { PATHS, options } from './options'
+import { options } from './options'
 import { execute, getPixiUrlFromVersion, pixiCmd } from './util'
 import { saveCache, tryRestoreCache } from './cache'

@@ -27,6 +28,7 @@ const pixiLogin = () => {
    core.debug('Skipping pixi login.')
    return Promise.resolve(0)
  }
+  core.debug(`auth keys: ${Object.keys(auth)}`)
  return core.group('Logging in to private channel', () => {
    // tokens get censored in the logs as long as they are a github secret
    if ('token' in auth) {
@@ -52,29 +54,58 @@ const pixiInstall = async () => {
    return Promise.resolve()
  }
  return tryRestoreCache()
-    .then((_cacheKey) => execute(pixiCmd('install')))
+    .then(async (_cacheKey) => {
+      if (options.environments) {
+        for (const environment of options.environments) {
+          core.debug(`Installing environment ${environment}`)
+          const command = `install -e ${environment}${options.frozen ? ' --frozen' : ''}${
+            options.locked ? ' --locked' : ''
+          }`
+          await core.group(`pixi ${command}`, () => execute(pixiCmd(command)))
+        }
+      } else {
+        const command = `install${options.frozen ? ' --frozen' : ''}${options.locked ? ' --locked' : ''}`
+        return core.group(`pixi ${command}`, () => execute(pixiCmd(command)))
+      }
+    })
    .then(saveCache)
 }

-const generatePixiRunShell = () => {
-  if (!options.generateRunShell) {
-    core.debug('Skipping pixi run shell generation.')
+const generateList = async () => {
+  if (!options.runInstall) {
+    core.debug('Skipping pixi list.')
    return Promise.resolve()
  }
-  if (os.platform() === 'win32') {
-    core.info('Skipping pixi run shell on Windows.')
+  if (
+    'version' in options.pixiSource &&
+    options.pixiSource.version !== 'latest' &&
+    options.pixiSource.version < 'v0.13.0'
+  ) {
+    core.warning(
+      'pixi list is not supported for pixi versions < `v0.13.0`. Please set `pixi-version` to `v0.13.0` or later.'
+    )
    return Promise.resolve()
  }
-  core.info('Generating pixi run shell.')
-  const pixiRunShellContents = `#!/usr/bin/env sh
-chmod +x $1
-pixi run $1
-`
-  return core.group('Generating pixi run shell', () => {
-    core.debug(`Writing pixi run shell to ${PATHS.pixiRunShellScript}`)
-    core.debug(`File contents:\n"${pixiRunShellContents}"`)
-    return fs.writeFile(PATHS.pixiRunShellScript, pixiRunShellContents, { encoding: 'utf8', mode: 0o755 })
-  })
+  let command = 'list'
+  if (
+    'version' in options.pixiSource &&
+    options.pixiSource.version !== 'latest' &&
+    options.pixiSource.version < 'v0.14.0'
+  ) {
+    if (options.frozen) core.warning('pixi versions < `v0.14.0` do not support the --frozen option for pixi list.')
+    if (options.locked) core.warning('pixi versions < `v0.14.0` do not support the --locked option for pixi list.')
+  } else {
+    command = `${command}${options.frozen ? ' --frozen' : ''}${options.locked ? ' --locked' : ''}`
+  }
+  if (options.environments) {
+    for (const environment of options.environments) {
+      core.debug(`Listing environment ${environment}`)
+      await core.group(`pixi ${command} -e ${environment}`, () => execute(pixiCmd(`${command} -e ${environment}`)))
+    }
+    return Promise.resolve()
+  } else {
+    return core.group(`pixi ${command}`, () => execute(pixiCmd(command)))
+  }
 }

 const generateInfo = () => core.group('pixi info', () => execute(pixiCmd('info')))
@@ -82,13 +113,26 @@ const generateInfo = () => core.group('pixi info', () => execute(pixiCmd('info')
 const run = async () => {
  core.debug(`process.env.HOME: ${process.env.HOME}`)
  core.debug(`os.homedir(): ${os.homedir()}`)
-  core.debug(`bashProfile ${PATHS.bashProfile}`)
-  await downloadPixi(options.pixiSource)
+  if (options.downloadPixi) {
+    await downloadPixi(options.pixiSource)
+  }
  addPixiToPath()
  await pixiLogin()
  await pixiInstall()
-  await generatePixiRunShell()
  await generateInfo()
+  await generateList()
 }

-run().catch((error) => core.setFailed(error.message))
+run().catch((error) => {
+  if (core.isDebug()) {
+    throw error
+  }
+  if (error instanceof Error) {
+    core.setFailed(error.message)
+    exit(1)
+  } else if (typeof error === 'string') {
+    core.setFailed(error)
+    exit(1)
+  }
+  throw error
+})
@@ -1,26 +1,33 @@
 import path from 'path'
 import os from 'os'
+import { exit } from 'process'
+import { existsSync, readFileSync } from 'fs'
 import * as core from '@actions/core'
 import * as z from 'zod'
-import { getCondaArch } from './util'
+import untildify from 'untildify'
+import { parse } from 'toml'
+import which from 'which'

-type Inputs = {
+type Inputs = Readonly<{
  pixiVersion?: string
  pixiUrl?: string
  logLevel?: LogLevel
  manifestPath?: string
  runInstall?: boolean
-  generateRunShell?: boolean
+  environments?: string[]
+  frozen?: boolean
+  locked?: boolean
  cache?: boolean
  cacheKey?: string
+  cacheWrite?: boolean
  pixiBinPath?: string
  authHost?: string
  authToken?: string
  authUsername?: string
  authPassword?: string
  authCondaToken?: string
-  postCleanup?: PostCleanup
-}
+  postCleanup?: boolean
+}>

 export type PixiSource =
  | {
@@ -45,39 +52,48 @@ type Auth = {
    }
 )

+type Cache = {
+  cacheKeyPrefix: string
+  cacheWrite: boolean
+}
+
 export type Options = Readonly<{
  pixiSource: PixiSource
+  downloadPixi: boolean
  logLevel: LogLevel
  manifestPath: string
  pixiLockFile: string
  runInstall: boolean
-  generateRunShell: boolean
-  cacheKey?: string // undefined if cache is false
+  environments?: string[]
+  frozen: boolean
+  locked: boolean
+  cache?: Cache
  pixiBinPath: string
  auth?: Auth
-  postCleanup: PostCleanup
+  postCleanup: boolean
 }>

-const logLevelSchema = z.enum(['quiet', 'warn', 'info', 'debug', 'trace'])
+const logLevelSchema = z.enum(['q', 'default', 'v', 'vv', 'vvv'])
 export type LogLevel = z.infer<typeof logLevelSchema>

-const postCleanupSchema = z.enum(['none', 'environment', 'all'])
-export type PostCleanup = z.infer<typeof postCleanupSchema>
-
 export const PATHS = {
-  pixiBin: path.join(os.homedir(), '.pixi', 'bin', `pixi${os.platform() === 'win32' ? '.exe' : ''}`),
-  pixiRunShellScript: path.join(os.homedir(), '.pixi', 'bin', 'pixi-shell'),
-  bashProfile: path.join(os.homedir(), '.bash_profile'),
-  bashrc: path.join(os.homedir(), '.bashrc')
+  pixiBin: path.join(os.homedir(), '.pixi', 'bin', `pixi${os.platform() === 'win32' ? '.exe' : ''}`)
 }

-const parseOrUndefined = <T>(key: string, schema: z.ZodSchema<T>): T | undefined => {
+const parseOrUndefined = <T>(key: string, schema: z.ZodSchema<T>, errorMessage?: string): T | undefined => {
  const input = core.getInput(key)
  // GitHub actions sets empty inputs to the empty string, but we want undefined
  if (input === '') {
    return undefined
  }
-  return schema.parse(input)
+  const maybeResult = schema.safeParse(input)
+  if (!maybeResult.success) {
+    if (!errorMessage) {
+      throw new Error(`${key} is not valid: ${maybeResult.error.message}`)
+    }
+    throw new Error(errorMessage)
+  }
+  return maybeResult.data
 }

 const parseOrUndefinedJSON = <T>(key: string, schema: z.ZodSchema<T>): T | undefined => {
@@ -89,6 +105,18 @@ const parseOrUndefinedJSON = <T>(key: string, schema: z.ZodSchema<T>): T | undef
  return schema.parse(JSON.parse(input))
 }

+const parseOrUndefinedList = <T>(key: string, schema: z.ZodSchema<T>): T[] | undefined => {
+  const input = core.getInput(key)
+  // GitHub actions sets empty inputs to the empty string, but we want undefined
+  if (input === '') {
+    return undefined
+  }
+  return input
+    .split(' ')
+    .map((s) => schema.parse(s))
+    .filter((s) => s !== '')
+}
+
 const validateInputs = (inputs: Inputs): void => {
  if (inputs.pixiVersion && inputs.pixiUrl) {
    throw new Error('You need to specify either pixi-version or pixi-url')
@@ -99,6 +127,15 @@ const validateInputs = (inputs: Inputs): void => {
  if (inputs.runInstall === false && inputs.cache === true) {
    throw new Error('Cannot cache without running install')
  }
+  if (inputs.runInstall === false && inputs.frozen === true) {
+    throw new Error('Cannot use `frozen: true` when not running install')
+  }
+  if (inputs.runInstall === false && inputs.locked === true) {
+    throw new Error('Cannot use `locked: true` when not running install')
+  }
+  if (inputs.locked === true && inputs.frozen === true) {
+    throw new Error('Cannot use `locked: true` and `frozen: true` at the same time')
+  }
  if ((inputs.authUsername && !inputs.authPassword) || (!inputs.authUsername && inputs.authPassword)) {
    throw new Error('You need to specify both auth-username and auth-password')
  }
@@ -119,6 +156,30 @@ const validateInputs = (inputs: Inputs): void => {
      throw new Error('You need to specify auth-host')
    }
  }
+  if (inputs.runInstall === false && inputs.environments) {
+    throw new Error('Cannot specify environments without running install')
+  }
+}
+
+const determinePixiInstallation = (pixiUrlOrVersionSet: boolean, pixiBinPath: string | undefined) => {
+  const preinstalledPixi = which.sync('pixi', { nothrow: true })
+
+  if (pixiUrlOrVersionSet || pixiBinPath) {
+    if (preinstalledPixi) {
+      core.debug(`Local pixi found at ${preinstalledPixi} is being ignored.`)
+    }
+    return {
+      downloadPixi: true,
+      pixiBinPath: pixiBinPath ? path.resolve(untildify(pixiBinPath)) : PATHS.pixiBin
+    }
+  }
+
+  if (preinstalledPixi) {
+    core.info(`Using pre-installed pixi at ${preinstalledPixi}`)
+    return { downloadPixi: false, pixiBinPath: preinstalledPixi }
+  }
+
+  return { downloadPixi: true, pixiBinPath: PATHS.pixiBin }
 }

 const inferOptions = (inputs: Inputs): Options => {
@@ -126,32 +187,77 @@ const inferOptions = (inputs: Inputs): Options => {
  const pixiSource = inputs.pixiVersion
    ? { version: inputs.pixiVersion }
    : inputs.pixiUrl
-    ? { url: inputs.pixiUrl }
-    : { version: 'latest' }
-  const logLevel = inputs.logLevel ?? (core.isDebug() ? 'debug' : 'warn')
-  const manifestPath = inputs.manifestPath ?? 'pixi.toml'
-  const pixiLockFile = path.basename(manifestPath).replace(/\.toml$/, '.lock')
-  const generateRunShell = inputs.generateRunShell ?? runInstall
-  const cacheKey = inputs.cacheKey ?? (inputs.cache ? `pixi-${getCondaArch()}` : undefined)
-  const pixiBinPath = inputs.pixiBinPath ?? PATHS.pixiBin
-  const auth = inputs.authHost
-    ? ({
-        host: inputs.authHost,
-        token: inputs.authToken,
-        username: inputs.authUsername,
-        password: inputs.authPassword,
-        condaToken: inputs.authCondaToken
-      } as Auth)
-    : undefined
-  const postCleanup = inputs.postCleanup ?? 'all'
+      ? { url: inputs.pixiUrl }
+      : { version: 'latest' }
+
+  const { downloadPixi, pixiBinPath } = determinePixiInstallation(
+    !!inputs.pixiVersion || !!inputs.pixiUrl,
+    inputs.pixiBinPath
+  )
+  const logLevel = inputs.logLevel ?? (core.isDebug() ? 'vv' : 'default')
+  // infer manifest path from inputs or default to pixi.toml or pyproject.toml depending on what is present in the repo.
+  let manifestPath = 'pixi.toml' // default
+  if (inputs.manifestPath) {
+    manifestPath = path.resolve(untildify(inputs.manifestPath))
+  } else {
+    if (existsSync('pixi.toml')) {
+      manifestPath = 'pixi.toml'
+    } else if (existsSync('pyproject.toml')) {
+      const fileContent = readFileSync('pyproject.toml', 'utf-8')
+      const parsedContent = parse(fileContent)
+      // only use pyproject.toml if [tool.pixi] is present
+      if (parsedContent.tool && parsedContent.tool.pixi) {
+        core.debug('The tool.pixi table found so using pyproject.toml as manifest file.')
+        manifestPath = 'pyproject.toml'
+      }
+    } else {
+      if (runInstall) {
+        core.warning('Could not find any manifest file. Defaulting to pixi.toml.')
+      }
+    }
+  }
+  const pixiLockFile = path.join(path.dirname(manifestPath), 'pixi.lock')
+  const lockFileAvailable = existsSync(pixiLockFile)
+  core.debug(`lockFileAvailable: ${lockFileAvailable}`)
+  if (!lockFileAvailable && inputs.cacheWrite === true) {
+    throw new Error('You cannot specify cache-write = true without a lock file present')
+  }
+  const cache = inputs.cacheKey
+    ? { cacheKeyPrefix: inputs.cacheKey, cacheWrite: inputs.cacheWrite ?? true }
+    : inputs.cache === true || (lockFileAvailable && inputs.cache !== false)
+      ? { cacheKeyPrefix: 'pixi-', cacheWrite: inputs.cacheWrite ?? true }
+      : undefined
+  const frozen = inputs.frozen ?? false
+  const locked = inputs.locked ?? (lockFileAvailable && !frozen)
+  const auth = !inputs.authHost
+    ? undefined
+    : ((inputs.authToken
+        ? {
+            host: inputs.authHost,
+            token: inputs.authToken
+          }
+        : inputs.authCondaToken
+          ? {
+              host: inputs.authHost,
+              condaToken: inputs.authCondaToken
+            }
+          : {
+              host: inputs.authHost,
+              username: inputs.authUsername!,
+              password: inputs.authPassword!
+            }) as Auth)
+  const postCleanup = inputs.postCleanup ?? true
  return {
    pixiSource,
+    downloadPixi,
    logLevel,
    manifestPath,
    pixiLockFile,
    runInstall,
-    generateRunShell,
-    cacheKey,
+    environments: inputs.environments,
+    frozen,
+    locked,
+    cache,
    pixiBinPath,
    auth,
    postCleanup
@@ -169,21 +275,32 @@ const assertOptions = (_options: Options) => {

 const getOptions = () => {
  const inputs: Inputs = {
-    pixiVersion: parseOrUndefined('pixi-version', z.union([z.literal('latest'), z.string().regex(/^v\d+\.\d+\.\d+$/)])),
+    pixiVersion: parseOrUndefined(
+      'pixi-version',
+      z.union([z.literal('latest'), z.string().regex(/^v\d+\.\d+\.\d+$/)]),
+      'pixi-version must either be `latest` or a version string matching `vX.Y.Z`.'
+    ),
    pixiUrl: parseOrUndefined('pixi-url', z.string().url()),
-    logLevel: parseOrUndefined('log-level', logLevelSchema),
+    logLevel: parseOrUndefined(
+      'log-level',
+      logLevelSchema,
+      'log-level must be one of `q`, `default`, `v`, `vv`, `vvv`.'
+    ),
    manifestPath: parseOrUndefined('manifest-path', z.string()),
    runInstall: parseOrUndefinedJSON('run-install', z.boolean()),
-    generateRunShell: parseOrUndefinedJSON('generate-run-shell', z.boolean()),
+    environments: parseOrUndefinedList('environments', z.string()),
+    locked: parseOrUndefinedJSON('locked', z.boolean()),
+    frozen: parseOrUndefinedJSON('frozen', z.boolean()),
    cache: parseOrUndefinedJSON('cache', z.boolean()),
    cacheKey: parseOrUndefined('cache-key', z.string()),
-    pixiBinPath: parseOrUndefined('micromamba-binary-path', z.string()),
+    cacheWrite: parseOrUndefinedJSON('cache-write', z.boolean()),
+    pixiBinPath: parseOrUndefined('pixi-bin-path', z.string()),
    authHost: parseOrUndefined('auth-host', z.string()),
    authToken: parseOrUndefined('auth-token', z.string()),
    authUsername: parseOrUndefined('auth-username', z.string()),
    authPassword: parseOrUndefined('auth-password', z.string()),
    authCondaToken: parseOrUndefined('auth-conda-token', z.string()),
-    postCleanup: parseOrUndefined('post-cleanup', postCleanupSchema)
+    postCleanup: parseOrUndefinedJSON('post-cleanup', z.boolean())
  }
  core.debug(`Inputs: ${JSON.stringify(inputs)}`)
  validateInputs(inputs)
@@ -193,4 +310,21 @@ const getOptions = () => {
  return options
 }

-export const options = getOptions()
+let _options: Options
+try {
+  _options = getOptions()
+} catch (error) {
+  if (core.isDebug()) {
+    throw error
+  }
+  if (error instanceof Error) {
+    core.setFailed(error.message)
+    exit(1)
+  } else if (typeof error === 'string') {
+    core.setFailed(error)
+    exit(1)
+  }
+  throw error
+}
+
+export const options = _options
@@ -1 +1,83 @@
-console.log('post')
+import fs from 'fs/promises'
+import path from 'path'
+import * as os from 'os'
+import { exit } from 'process'
+import * as core from '@actions/core'
+import { options } from './options'
+
+const removeEmptyParentDirs = (dirPath: string): Promise<void> => {
+  return fs.readdir(dirPath).then((files) => {
+    if (files.length === 0) {
+      core.debug(`Removing empty directory ${dirPath}.`)
+      return fs.rm(dirPath, { recursive: true }).then(() => {
+        const parentDir = path.dirname(dirPath)
+        if (parentDir !== dirPath) {
+          return removeEmptyParentDirs(parentDir)
+        }
+      })
+    }
+    return Promise.resolve()
+  })
+}
+
+const cleanupPixiBin = () => {
+  const pixiBinPath = options.pixiBinPath
+  const pixiBinDir = path.dirname(pixiBinPath)
+  core.debug(`Cleaning up pixi binary ${pixiBinPath}.`)
+  return fs.rm(pixiBinPath).then(() => removeEmptyParentDirs(pixiBinDir))
+}
+
+const cleanupEnv = () => {
+  if (!options.runInstall) {
+    core.debug('Skipping cleanup of .pixi directory.')
+    return Promise.resolve()
+  }
+  const envDir = path.join(path.dirname(options.manifestPath), '.pixi')
+  core.debug(`Cleaning up .pixi directory ${envDir}.`)
+  return fs.rm(envDir, { recursive: true })
+}
+
+const determineCacheDir = () => {
+  // rattler uses dirs::cache_dir https://docs.rs/dirs/latest/dirs/fn.cache_dir.html
+  if (os.platform() === 'win32') {
+    return process.env.LOCALAPPDATA!
+  }
+  if (os.platform() === 'linux') {
+    return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache')
+  }
+  return path.join(os.homedir(), 'Library', 'Caches')
+}
+
+const cleanupRattler = () => {
+  const rattlerPath = path.join(os.homedir(), '.rattler')
+  const cacheDir = determineCacheDir()
+  const rattlerCachePath = path.join(cacheDir, 'rattler')
+  core.debug(`Cleaning up rattler directories ${rattlerPath} and ${rattlerCachePath}.`)
+  return Promise.all([
+    fs.rm(rattlerPath, { recursive: true, force: true }),
+    fs.rm(rattlerCachePath, { recursive: true, force: true })
+  ])
+}
+
+const run = () => {
+  const postCleanup = options.postCleanup
+  if (postCleanup) {
+    return Promise.all([cleanupPixiBin(), cleanupEnv(), cleanupRattler()])
+  }
+  core.debug('Skipping post-cleanup.')
+  return Promise.resolve()
+}
+
+run().catch((error) => {
+  if (core.isDebug()) {
+    throw error
+  }
+  if (error instanceof Error) {
+    core.setFailed(error.message)
+    exit(1)
+  } else if (typeof error === 'string') {
+    core.setFailed(error)
+    exit(1)
+  }
+  throw error
+})
@@ -78,19 +78,20 @@ export const pixiCmd = (command: string, withManifestPath = true) => {
  if (withManifestPath) {
    commandArray = commandArray.concat(['--manifest-path', options.manifestPath])
  }
+  commandArray = commandArray.concat(['--color', 'always'])
  switch (options.logLevel) {
-    case 'trace':
+    case 'vvv':
      commandArray = commandArray.concat(['-vvv'])
      break
-    case 'debug':
+    case 'vv':
      commandArray = commandArray.concat(['-vv'])
      break
-    case 'info':
+    case 'v':
      commandArray = commandArray.concat(['-v'])
      break
-    case 'warn':
+    case 'default':
      break
-    case 'quiet':
+    case 'q':
      commandArray = commandArray.concat(['-q'])
      break
  }
@@ -0,0 +1,14 @@
+[project]
+name = "test-auth"
+version = "0.1.0"
+description = "Add a short description here"
+authors = ["Pavel"]
+channels = ["conda-forge", "https://repo.prefix.dev/setup-pixi-test"]
+platforms = ["osx-arm64", "osx-64", "linux-64", "linux-aarch64", "win-64"]
+
+[tasks]
+test = "python -c 'print(\"Hello world!\")'"
+
+[dependencies]
+python = "3.9.*"
+private-package = "*"
@@ -4,9 +4,10 @@ version = "0.1.0"
 description = "Add a short description here"
 authors = ["Pavel Zwerschke <pavelzw@gmail.com>"]
 channels = ["conda-forge"]
-platforms = ["linux-64", "osx-64", "win-64"]
+platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"]

 [tasks]
+test = "python -c 'print(\"Hello world!\")'"

 [dependencies]
 python = "3.11.*"
@@ -0,0 +1,14 @@
+[project]
+name = "test-default"
+version = "0.1.0"
+description = "Add a short description here"
+authors = ["Pavel Zwerschke <pavelzw@gmail.com>"]
+channels = ["conda-forge"]
+platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"]
+
+[tasks]
+test = "python -c 'print(\"Hello world!\")'"
+
+[dependencies]
+# the lockfile still has python 3.10.*
+python = "3.11.*"
@@ -0,0 +1,18 @@
+[project]
+name = "test-package"
+channels = ["conda-forge"]
+platforms = ["linux-64", "osx-arm64", "osx-64", "win-64"]
+
+[dependencies]
+python = ">=3.11"
+pip = "*"
+polars = ">=0.14.24,<0.21"
+
+[feature.py311.dependencies]
+python = "3.11.*"
+[feature.py312.dependencies]
+python = "3.12.*"
+
+[environments]
+py311 = ["py311"]
+py312 = ["py312"]
@@ -7,6 +7,7 @@ channels = ["conda-forge"]
 platforms = ["linux-64", "osx-64", "win-64"]

 [tasks]
+test = "python -c 'print(\"Hello world!\")'"

 [dependencies]
 python = "3.11.*"
@@ -0,0 +1,13 @@
+[project]
+name = "test-default"
+version = "0.1.0"
+description = "Add a short description here"
+authors = ["Pavel Zwerschke <pavelzw@gmail.com>"]
+channels = ["conda-forge"]
+platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"]
+
+[tasks]
+test = "python -c 'print(\"Hello world!\")'"
+
+[dependencies]
+python = "3.11.*"
@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Pavel Zwerschke
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@@ -0,0 +1,28 @@
+package:
+  name: private-package
+  version: 0.0.1
+
+build:
+  noarch: python
+  script: echo this is a noop
+  number: 0
+
+requirements:
+  run:
+    - python >=3.9
+
+test:
+  commands:
+    - echo this is a noop
+
+about:
+  home: http://github.com/prefix-dev/setup-pixi
+  license: BSD-3-Clause
+  license_file: LICENSE
+  description: |
+    This is a test package for setup-pixi.
+  dev_url: http://github.com/prefix-dev/setup-pixi
+
+extra:
+  recipe-maintainers:
+    - pavelzw
@@ -0,0 +1,22 @@
+[project]
+name = "pyproject-manifest"
+version = "0.1.0"
+description = "Testing pyproject-manifest."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = ["flask==2.*"]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pixi.project]
+name = "pyproject-manifest"
+channels = ["conda-forge"]
+platforms = ["linux-64", "osx-arm64", "osx-64", "win-64"]
+
+[tool.pixi.pypi-dependencies]
+boltons = "*"
+
+[tool.pixi.tasks]
+test = "echo 'Running tests...'"
@@ -19,6 +19,8 @@ export default defineConfig({
    '@actions/io',
    '@actions/tool-cache',
    'untildify',
+    'toml',
+    'which',
    'zod'
  ]
 })