Fix saving cache taking too long (#113)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/PULL_REQUEST_TEMPLATE.md

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

.github/dependabot.yml

@@ -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"
+          - "*"

.github/workflows/build.yml

@@ -6,6 +6,8 @@ on:
   pull_request:
     branches: [main]
   merge_group:
+  schedule:
+    - cron: 0 6 * * MON
 
 jobs:
   build:
@@ -14,7 +16,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Install pnpm
-        uses: pnpm/action-setup@v2
+        uses: pnpm/action-setup@v4
         with:
           version: 8
 
@@ -29,7 +31,7 @@ jobs:
 
       - name: Rebuild the dist/ directory
         run: pnpm build
-      
+
       - name: Lint
         run: pnpm lint
 
@@ -41,10 +43,81 @@ jobs:
 
       - name: Assert latest setup-pixi version is mentioned in README
         run: |
+          set -euo pipefail
           latest_version="$(jq -r '.version' package.json)"
-          count_expected=10
+          count_expected=15
           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."
+            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@6d6857d36972b65feb161a90e484f2984215f83e
+        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@v4
+        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/

.github/workflows/check-dist.yml

@@ -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@v4
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v2
-        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@v3
-        if: ${{ failure() && steps.diff.conclusion == 'failure' }}
-        with:
-          name: dist
-          path: dist/

.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Quantco/ui-actions/version-metadata@v1
+      - 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@69320dbe05506a9a39fc8ae11030b214ec2d1f87
         with:
           generate_release_notes: true
           tag_name: v${{ steps.version-metadata.outputs.newVersion }}

.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
   default:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-13]
         cache: [true, false]
     runs-on: ${{ matrix.os }}
     name: default ${{ matrix.cache == true && 'with' || 'without' }} cache (${{ matrix.os }})
@@ -26,15 +26,15 @@ jobs:
       - 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/env/python.exe
-          ./.pixi/env/python.exe --version | grep -q 3.11
+          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: |
@@ -58,15 +58,30 @@ jobs:
           ! test -d .pixi
         shell: bash
 
-  custom-pixi-version:
+  no-pixi-toml:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          run-install: false
+      - run: |
+          ! test -d .pixi
+        shell: bash
+      - run: pixi info
+
+  custom-pixi-version:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-13]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
       - name: Move pixi.toml
-        run: mv test/default/* .
+        run: mv test/old-pixi-lockfiles/* .
       - uses: ./
         with:
           cache: false
@@ -75,6 +90,58 @@ jobs:
           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-13]
+    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-13]
+    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:
@@ -110,15 +177,13 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Move pixi.toml
-        run: mv test/default/* .
+        run: mv test/old-pixi-lockfiles/* .
       - uses: ./
         with:
           cache: false
-          pixi-url: https://github.com/prefix-dev/pixi/releases/download/v0.0.8/pixi-x86_64-unknown-linux-musl
-          # pixi 0.0.8 doesn't support --locked
-          locked: false
-      - run: pixi --version | grep -q "pixi 0.0.8"
-  
+          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:
@@ -130,7 +195,7 @@ jobs:
         with:
           cache: false
           manifest-path: test/default/pixi.toml
-  
+
   different-log-level:
     strategy:
       matrix:
@@ -165,6 +230,126 @@ jobs:
         # 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:
@@ -180,9 +365,8 @@ jobs:
           auth-host: https://custom-conda-registry.com
           auth-token: custom-token
       - run: |
-          grep -q "BearerToken" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-conda-registry.com" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-token" ~/.rattler/rattler_auth_store.json
+          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'
@@ -203,10 +387,9 @@ jobs:
           auth-username: custom-username
           auth-password: custom-password
       - run: |
-          grep -q "BasicHTTP" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-conda-registry.com" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-username" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-password" ~/.rattler/rattler_auth_store.json
+          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'
@@ -226,10 +409,8 @@ jobs:
           auth-host: https://custom-conda-registry.com
           auth-conda-token: custom-conda-token
       - run: |
-          grep "CondaToken" ~/.rattler/rattler_auth_store.json
-          cat ~/.rattler/rattler_auth_store.json
-          grep -q "custom-conda-registry.com" ~/.rattler/rattler_auth_store.json
-          grep -q "custom-conda-token" ~/.rattler/rattler_auth_store.json
+          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'
@@ -250,7 +431,7 @@ jobs:
           auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
       - name: Ensure private-package is installed
         run: |
-          test -f .pixi/env/conda-meta/private-package-0.0.1-0.json
+          test -f .pixi/envs/default/conda-meta/private-package-0.0.1-0.json
 
   pixi-shell:
     strategy:
@@ -266,13 +447,15 @@ jobs:
           cache: false
       - run: |
           python --version | grep -q "3.11"
-        shell: pixi run bash {0}
+        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:
@@ -361,7 +544,7 @@ jobs:
         with:
           cache: false
           post-cleanup: ${{ matrix.post-cleanup }}
-    
+
   no-lockfile:
     strategy:
       matrix:
@@ -372,24 +555,77 @@ jobs:
       - 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/env/python.exe
-          ./.pixi/env/python.exe --version | grep -q 3.11
+          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-13]
+        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-13]
+    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
@@ -397,7 +633,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-13]
     steps:
       - uses: actions/checkout@v4
       - name: Move pixi files
@@ -408,10 +644,10 @@ jobs:
           cache-key: test-cache-${{ github.sha }}-${{ github.run_attempt }}-
       # check the action logs to see if the cache was written
       - run: |
-          test -f .pixi/env/bin/python
+          test -f .pixi/envs/default/bin/python
         if: matrix.os != 'windows-latest'
       - run: |
-          test -f .pixi/env/python.exe
+          test -f .pixi/envs/default/python.exe
         if: matrix.os == 'windows-latest'
 
   test-cache2:
@@ -422,7 +658,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-13]
     steps:
       - uses: actions/checkout@v4
       - name: Move pixi files
@@ -433,10 +669,10 @@ jobs:
           cache-key: test-cache-${{ github.sha }}-${{ github.run_attempt }}-
       # check the action logs to see if the cache was restored
       - run: |
-          test -f .pixi/env/bin/python
+          test -f .pixi/envs/default/bin/python
         if: matrix.os != 'windows-latest'
       - run: |
-          test -f .pixi/env/python.exe
+          test -f .pixi/envs/default/python.exe
         if: matrix.os == 'windows-latest'
 
   test-cache-no-write:
@@ -446,7 +682,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest, ubuntu-latest, macos-latest, macos-13]
     steps:
       - uses: actions/checkout@v4
       - name: Move pixi files
@@ -458,6 +694,136 @@ jobs:
           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
+
+  environment-activation-unix:
+    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:
+          activate-environment: true
+      - run: which python | grep '.pixi/envs/default/bin/python'
+      - run: env | grep CONDA_PREFIX
+      - run: '[[ $PIXI_ENVIRONMENT_NAME = "default" ]]'
+
+  environment-activation-windows-bash:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          activate-environment: true
+      - run: which python | grep '.pixi/envs/default/python'
+      - run: env | grep CONDA_PREFIX
+      - run: '[[ $PIXI_ENVIRONMENT_NAME = "default" ]]'
+
+  environment-activation-windows-pwsh:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: pwsh
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          activate-environment: true
+      - run: if (-Not (Get-Command python).Path -like '*\.pixi\envs\default\python') { exit 1 }
+      - run: if (!$env:CONDA_PREFIX) { exit 1 }
+      - run: if ($env:PIXI_ENVIRONMENT_NAME -ne "default") { exit 1 }
+
+  environment-activation-windows-cmd:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: cmd
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          activate-environment: true
+      - run: where python | findstr "\.pixi\\envs\\default\\python.exe"
+      - run: set | findstr CONDA_PREFIX
+      - run: |
+          if defined PIXI_ENVIRONMENT_NAME (
+            if "%PIXI_ENVIRONMENT_NAME%" NEQ "default" (
+              exit 1
+            )
+          )
+
+  environment-activation-false:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/default/* .
+      - uses: ./
+        with:
+          activate-environment: false
+      - run: '[[ $PIXI_ENVIRONMENT_NAME = "" ]]'
+
+  environment-activation-explicit-env:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/multiple-environments/* .
+      - uses: ./
+        with:
+          environments: py311
+          activate-environment: true
+      - run: which python | grep '.pixi/envs/py311/bin/python'
+      - run: '[[ $PIXI_ENVIRONMENT_NAME = "py311" ]]'
+
+  environment-activation-multiple-env:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Move pixi.toml
+        run: mv test/multiple-environments/* .
+      - uses: ./
+        with:
+          environments: >-
+            py311 py312
+          activate-environment: py311
+      - run: which python | grep '.pixi/envs/py311/bin/python'
+      - run: '[[ $PIXI_ENVIRONMENT_NAME = "py311" ]]'
+
   # not properly testable
   # https://github.com/actions/runner/issues/2347
   # https://github.com/orgs/community/discussions/15452
@@ -558,3 +924,18 @@ jobs:
   #       # 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

.gitignore

@@ -97,3 +97,6 @@ Thumbs.db
 # Ignore built ts files
 __tests__/runner/*
 lib/**/*
+
+# Ignore jetbrains files
+.idea

README.md

@@ -23,9 +23,9 @@ GitHub Action to set up the [pixi](https://github.com/prefix-dev/pixi) package m
 ## Usage
 
 ```yml
-- uses: prefix-dev/setup-pixi@v0.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
-    pixi-version: v0.7.0
+    pixi-version: v0.22.0
     cache: true
     auth-host: prefix.dev
     auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
@@ -34,8 +34,23 @@ GitHub Action to set up the [pixi](https://github.com/prefix-dev/pixi) package m
 
 > [!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.4.1`) to avoid breaking changes.
+> Please pin the versions of this action to a specific version (i.e., `prefix-dev/setup-pixi@v0.8.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
 
@@ -58,12 +73,75 @@ In order to not exceed the [10 GB cache size limit](https://docs.github.com/en/a
 This can be done by setting the `cache-write` argument.
 
 ```yml
-- uses: prefix-dev/setup-pixi@v0.4.1
+- uses: prefix-dev/setup-pixi@v0.8.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.8.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.8.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:
@@ -85,7 +163,7 @@ 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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
     auth-host: prefix.dev
     auth-token: ${{ secrets.PREFIX_DEV_TOKEN }}
@@ -97,7 +175,7 @@ Specify the username and password using the `auth-username` and `auth-password`
 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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
     auth-host: custom-artifactory.com
     auth-username: ${{ secrets.PIXI_USERNAME }}
@@ -110,7 +188,7 @@ 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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
     auth-host: anaconda.org # or my-quetz-instance.com
     conda-token: ${{ secrets.CONDA_TOKEN }}
@@ -118,17 +196,17 @@ This form of authentication (token is encoded in URL: `https://my-quetz-instance
 
 ### 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 {0}`.
+`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 {0}
+    pip install --no-deps -e .
+  shell: pixi run bash -e {0}
 ```
 
-You can even run python scripts like this:
+You can even run Python scripts like this:
 
 ```yml
 - run: | # everything here will be run inside of the pixi environment
@@ -137,18 +215,52 @@ You can even run python scripts like this:
   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.
 
+### Environment activation
+
+Instead of using a custom shell wrapper, you can also make all pixi-installed binaries available to subsequent steps by "activating" the installed environment in the currently running job.
+To this end, `setup-pixi` adds all environment variables set when executing `pixi run` to `$GITHUB_ENV` and, similarly, adds all path modifications to `$GITHUB_PATH`.
+As a result, all installed binaries can be accessed without having to call `pixi run`.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.8.0
+  with:
+    activate-environment: true
+```
+
+If you are installing multiple environments, you will need to specify the name of the environment that you want to be activated.
+
+```yml
+- uses: prefix-dev/setup-pixi@v0.8.0
+  with:
+    environments: >-
+      py311
+      py312
+    activate-environment: py311
+```
+
+Activating an environment may be more useful than using a custom shell wrapper as it allows non-shell based steps to access binaries on the path.
+However, be aware that this option augments the environment of your job.
+
 ### `--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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
     locked: true
     # or
@@ -167,7 +279,7 @@ 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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   env:
     RUNNER_DEBUG: true
 ```
@@ -185,13 +297,13 @@ 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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.0
   with:
     # one of `q`, `default`, `v`, `vv`, or `vvv`.
     log-level: vvv
 ```
 
-If nothing is specified, `setup-pixi` will default to `default` or `vv` depending on if [debug logging is enabled for the action](#debug-logging-of-the-action).
+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
 
@@ -206,18 +318,32 @@ If you set `post-cleanup` to `true`, the action will delete the following files:
 - the rattler cache
 - other rattler files in `~/.rattler`
 
-If nothing is specified, `setup-pixi` will default to `true`.
+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.4.1
+- uses: prefix-dev/setup-pixi@v0.8.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.8.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).
@@ -225,6 +351,6 @@ If you want to see more examples, you can take a look at the [GitHub Workflows o
 ## Local Development
 
 1. Clone this repository.
-1. Run `pnpm install` inside the repository (if you don't have [`pnpm`](https://github.com/pnpm/pnpm) installed, you can install it with `npm install -g pnpm` or `brew install pnpm`).
-1. Run `pnpm dev` for live transpilation of the TypeScript source code.
-1. To test the action, you can run [`act`](https://github.com/nektos/act) (inside docker) or use :sparkles: CI driven development :sparkles:.
+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:.

action.yml

@@ -18,8 +18,17 @@ inputs:
     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`.
+  environments:
+    description: |
+      A space-separated list of environments to install. If not specified, only the default environment is installed.
+  activate-environment:
+    description: |
+      If the installed environment should be "activated" for the current job, modifying `$GITHUB_ENV` and
+      `$GITHUB_PATH`. If more than one environment is specified in `environments`, this must be the name of the
+      environment. Defaults to `false`. Requires at least pixi v0.21.0.
   locked:
-    description: Whether to use `pixi install --locked`. Defaults to `true` when the lockfile is present, otherwise `false`.
+    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:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "setup-pixi",
-  "version": "0.4.1",
+  "version": "0.8.0",
   "private": true,
   "description": "Action to set up the pixi package manager.",
   "scripts": {
@@ -21,27 +21,30 @@
   "author": "Pavel Zwerschke <pavelzw@gmail.com>",
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@actions/cache": "^3.2.2",
+    "@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",
+    "which": "^4.0.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@types/node": "^20.9.0",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
-    "eslint": "^8.53.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.29.0",
-    "eslint-plugin-n": "^16.3.1",
-    "eslint-plugin-prettier": "^5.0.1",
+    "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.1.0",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2"
+    "prettier": "^3.2.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.3"
   }
 }

src/activate.ts

@@ -0,0 +1,69 @@
+import * as os from 'os'
+import * as osPath from 'path'
+import * as core from '@actions/core'
+import { executeGetOutput, pixiCmd } from './util'
+
+type ShellHook = {
+  environment_variables: Record<string, string>
+}
+
+const splitEnvironment = (shellHook: ShellHook): [Record<string, string>, string?] => {
+  if (os.platform() === 'win32') {
+    // On Windows, environment variables are case-insensitive but JSON isn't...
+    const pathEnvs = Object.keys(shellHook.environment_variables).filter((k) => k.toUpperCase() === 'PATH')
+    if (pathEnvs) {
+      const caseSensitivePathName = pathEnvs[0]
+      const path = shellHook.environment_variables[caseSensitivePathName]
+      delete shellHook.environment_variables[caseSensitivePathName]
+      return [shellHook.environment_variables, path]
+    }
+  } else {
+    if ('PATH' in shellHook.environment_variables) {
+      const path = shellHook.environment_variables.PATH
+      delete shellHook.environment_variables.PATH
+      return [shellHook.environment_variables, path]
+    }
+  }
+
+  // If the path cannot be found, return all other environment variables
+  return [shellHook.environment_variables]
+}
+
+const getNewPathComponents = (path: string): string[] => {
+  const currentPath = process.env.PATH
+  if (!currentPath) {
+    throw new Error('Unable to obtain current PATH from environment')
+  }
+  if (!path.endsWith(currentPath)) {
+    throw new Error('Unable to handle environment activation which does not only append to PATH')
+  }
+  core.debug(`Found current path '${currentPath}'`)
+  core.debug(`Got new path '${path}'`)
+  const newPath = path.slice(0, path.length - currentPath.length)
+  return newPath.split(osPath.delimiter).filter((p) => p.length > 0)
+}
+
+export const activateEnvironment = async (environment: string): Promise<void> => {
+  // First, obtain the environment variables that would be set by environment activation
+  const envOption = environment === 'default' ? '' : `-e ${environment}`
+  const shellHookOutput = await executeGetOutput(pixiCmd(`shell-hook ${envOption} --json`), { silent: true })
+  const shellHook: ShellHook = JSON.parse(shellHookOutput.stdout)
+
+  // Then, we split the environment variables into the special 'PATH' and all others
+  const [envVars, path] = splitEnvironment(shellHook)
+
+  // Finally, new path components are added...
+  if (path) {
+    const newComponents = getNewPathComponents(path)
+    for (const component of newComponents) {
+      core.info(`Adding path component '${component}'`)
+      core.addPath(component)
+    }
+  }
+
+  // ... as well as all remaining environment variables
+  for (const key of Object.keys(envVars)) {
+    core.info(`Exporting environment variable '${key}=${envVars[key]}'`)
+    core.exportVariable(key, envVars[key])
+  }
+}

src/cache.ts

@@ -6,14 +6,23 @@ import { options } from './options'
 import { getCondaArch, sha256 } from './util'
 
 export const generateCacheKey = async (cacheKeyPrefix: string) =>
-  fs
-    .readFile(options.pixiLockFile, 'utf-8')
-    .then((content) => {
-      const contentsSha = 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 lockFileSha = sha256(options.pixiLockFile)
-      const sha = sha256(contentsSha + lockFileSha)
+      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) => {

src/main.ts

@@ -8,6 +8,7 @@ import type { PixiSource } from './options'
 import { options } from './options'
 import { execute, getPixiUrlFromVersion, pixiCmd } from './util'
 import { saveCache, tryRestoreCache } from './cache'
+import { activateEnvironment } from './activate'
 
 const downloadPixi = (source: PixiSource) => {
   const url = 'version' in source ? getPixiUrlFromVersion(source.version) : source.url
@@ -54,34 +55,92 @@ const pixiInstall = async () => {
     return Promise.resolve()
   }
   return tryRestoreCache()
-    .then((_cacheKey) =>
-      execute(pixiCmd(`install${options.frozen ? ' --frozen' : ''}${options.locked ? ' --locked' : ''}`))
-    )
+    .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 generateList = async () => {
+  if (!options.runInstall) {
+    core.debug('Skipping pixi list.')
+    return Promise.resolve()
+  }
+  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()
+  }
+  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')))
 
+const activateEnv = (environment: string) => core.group('Activate environment', () => activateEnvironment(environment))
+
 const run = async () => {
   core.debug(`process.env.HOME: ${process.env.HOME}`)
   core.debug(`os.homedir(): ${os.homedir()}`)
-  await downloadPixi(options.pixiSource)
+  if (options.downloadPixi) {
+    await downloadPixi(options.pixiSource)
+  }
   addPixiToPath()
   await pixiLogin()
   await pixiInstall()
   await generateInfo()
+  await generateList()
+  if (options.activatedEnvironment) {
+    await activateEnv(options.activatedEnvironment)
+  }
 }
 
-run().catch((error) => {
-  if (core.isDebug()) {
+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
-  }
-  if (error instanceof Error) {
-    core.setFailed(error.message)
-    exit(1)
-  } else if (typeof error === 'string') {
-    core.setFailed(error)
-    exit(1)
-  }
-  throw error
-})
+  })
+  .then(() => exit(0)) // workaround for https://github.com/actions/toolkit/issues/1578

src/options.ts

@@ -1,17 +1,21 @@
 import path from 'path'
 import os from 'os'
 import { exit } from 'process'
-import { existsSync } from 'fs'
+import { existsSync, readFileSync } from 'fs'
 import * as core from '@actions/core'
 import * as z from 'zod'
 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
+  environments?: string[]
+  activateEnvironment?: boolean | string
   frozen?: boolean
   locked?: boolean
   cache?: boolean
@@ -24,7 +28,7 @@ type Inputs = {
   authPassword?: string
   authCondaToken?: string
   postCleanup?: boolean
-}
+}>
 
 export type PixiSource =
   | {
@@ -56,16 +60,19 @@ type Cache = {
 
 export type Options = Readonly<{
   pixiSource: PixiSource
+  downloadPixi: boolean
   logLevel: LogLevel
   manifestPath: string
   pixiLockFile: string
   runInstall: boolean
+  environments?: string[]
   frozen: boolean
   locked: boolean
   cache?: Cache
   pixiBinPath: string
   auth?: Auth
   postCleanup: boolean
+  activatedEnvironment?: string
 }>
 
 const logLevelSchema = z.enum(['q', 'default', 'v', 'vv', 'vvv'])
@@ -100,6 +107,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')
@@ -139,9 +158,33 @@ const validateInputs = (inputs: Inputs): void => {
       throw new Error('You need to specify auth-host')
     }
   }
-  if (inputs.cacheWrite && !inputs.cacheKey && !inputs.cache) {
-    throw new Error('cache-write is only valid with cache-key or cache specified.')
+  if (inputs.runInstall === false && inputs.environments) {
+    throw new Error('Cannot specify environments without running install')
   }
+  if (inputs.activateEnvironment === 'true' && inputs.environments && inputs.environments.length > 1) {
+    throw new Error('When installing multiple environments, `activate-environment` must specify the environment name')
+  }
+}
+
+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 => {
@@ -151,17 +194,54 @@ const inferOptions = (inputs: Inputs): Options => {
     : inputs.pixiUrl
       ? { url: inputs.pixiUrl }
       : { version: 'latest' }
+
+  const { downloadPixi, pixiBinPath } = determinePixiInstallation(
+    !!inputs.pixiVersion || !!inputs.pixiUrl,
+    inputs.pixiBinPath
+  )
   const logLevel = inputs.logLevel ?? (core.isDebug() ? 'vv' : 'default')
-  const manifestPath = inputs.manifestPath ? path.resolve(untildify(inputs.manifestPath)) : 'pixi.toml'
-  const pixiLockFile = path.join(path.dirname(manifestPath), path.basename(manifestPath).replace(/\.toml$/, '.lock'))
+  // 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')
+  }
+  let activatedEnvironment // default is undefined
+  if (inputs.activateEnvironment === 'true') {
+    if (inputs.environments) {
+      activatedEnvironment = inputs.environments[0]
+    } else {
+      activatedEnvironment = 'default'
+    }
+  } else if (inputs.activateEnvironment && inputs.activateEnvironment !== 'false') {
+    activatedEnvironment = inputs.activateEnvironment
+  }
   const cache = inputs.cacheKey
     ? { cacheKeyPrefix: inputs.cacheKey, cacheWrite: inputs.cacheWrite ?? true }
     : inputs.cache === true || (lockFileAvailable && inputs.cache !== false)
-      ? { cacheKeyPrefix: 'pixi-', cacheWrite: true }
+      ? { cacheKeyPrefix: 'pixi-', cacheWrite: inputs.cacheWrite ?? true }
       : undefined
-  const pixiBinPath = inputs.pixiBinPath ? path.resolve(untildify(inputs.pixiBinPath)) : PATHS.pixiBin
   const frozen = inputs.frozen ?? false
   const locked = inputs.locked ?? (lockFileAvailable && !frozen)
   const auth = !inputs.authHost
@@ -184,10 +264,13 @@ const inferOptions = (inputs: Inputs): Options => {
   const postCleanup = inputs.postCleanup ?? true
   return {
     pixiSource,
+    downloadPixi,
     logLevel,
     manifestPath,
     pixiLockFile,
     runInstall,
+    environments: inputs.environments,
+    activatedEnvironment,
     frozen,
     locked,
     cache,
@@ -221,6 +304,8 @@ const getOptions = () => {
     ),
     manifestPath: parseOrUndefined('manifest-path', z.string()),
     runInstall: parseOrUndefinedJSON('run-install', z.boolean()),
+    environments: parseOrUndefinedList('environments', z.string()),
+    activateEnvironment: parseOrUndefined('activate-environment', z.string()),
     locked: parseOrUndefinedJSON('locked', z.boolean()),
     frozen: parseOrUndefinedJSON('frozen', z.boolean()),
     cache: parseOrUndefinedJSON('cache', z.boolean()),

src/util.ts

@@ -2,7 +2,8 @@ import type { BinaryLike } from 'crypto'
 import { createHash } from 'crypto'
 import * as os from 'os'
 import * as core from '@actions/core'
-import { exec } from '@actions/exec'
+import type { ExecOptions } from '@actions/exec'
+import { exec, getExecOutput } from '@actions/exec'
 import { options } from './options'
 
 export const getCondaArch = () => {
@@ -73,11 +74,17 @@ export const execute = (cmd: string[]) => {
   return exec(cmd[0], cmd.slice(1))
 }
 
+export const executeGetOutput = (cmd: string[], options?: ExecOptions) => {
+  core.debug(`Executing: ${cmd.join(' ')}`)
+  return getExecOutput(cmd[0], cmd.slice(1), options)
+}
+
 export const pixiCmd = (command: string, withManifestPath = true) => {
-  let commandArray = [options.pixiBinPath].concat(command.split(' '))
+  let commandArray = [options.pixiBinPath].concat(command.split(' ').filter((x) => x !== ''))
   if (withManifestPath) {
     commandArray = commandArray.concat(['--manifest-path', options.manifestPath])
   }
+  commandArray = commandArray.concat(['--color', 'always'])
   switch (options.logLevel) {
     case 'vvv':
       commandArray = commandArray.concat(['-vvv'])

test/default/pixi.toml

@@ -4,7 +4,7 @@ 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!\")'"

test/multiple-environments/pixi.toml

@@ -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"]

test/no-lockfile/pixi.toml

@@ -4,7 +4,7 @@ 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!\")'"

test/old-pixi-lockfiles/pixi.toml

@@ -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.*"

test/pyproject-manifest/pyproject.toml

@@ -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...'"

tsup.config.js

@@ -19,6 +19,8 @@ export default defineConfig({
     '@actions/io',
     '@actions/tool-cache',
     'untildify',
+    'toml',
+    'which',
     'zod'
   ]
 })