Do not warn when version not in manifest-file (#462)

This will spam the GitHub summary with warnings as soon as a new version
is released and no new setup-uv version containing this version in the
distributed manifest-file is released

Closes: #461

.github/actionlint.yaml

@@ -0,0 +1,9 @@
+self-hosted-runner:
+  # Custom labels of self-hosted or large GitHub hosted runners
+  # so that actionlint knows that they are not a typo
+  labels:
+    - selfhosted-ubuntu-arm64
+# Configuration variables in array of strings defined in your repository or
+# organization. `null` means disabling configuration variables check.
+# Empty array means no configuration variable is allowed.
+config-variables: null

.github/release-drafter.yml

@@ -19,7 +19,7 @@ categories:
     labels:
       - "maintenance"
       - "ci"
-      - "update-known-checksums"
+      - "update-known-versions"
   - title: "📚 Documentation"
     labels:
       - "documentation"

.github/scripts/check-all-tests-passed-needs.ts

@@ -0,0 +1,35 @@
+import * as fs from "node:fs";
+import * as yaml from "js-yaml";
+
+interface WorkflowJob {
+  needs?: string[];
+  [key: string]: unknown;
+}
+
+interface Workflow {
+  jobs: Record<string, WorkflowJob>;
+  [key: string]: unknown;
+}
+
+const workflow = yaml.load(
+  fs.readFileSync("../workflows/test.yml", "utf8"),
+) as Workflow;
+const jobs = Object.keys(workflow.jobs);
+const allTestsPassed = workflow.jobs["all-tests-passed"];
+const needs: string[] = allTestsPassed.needs || [];
+
+const expectedNeeds = jobs.filter((j) => j !== "all-tests-passed");
+const missing = expectedNeeds.filter((j) => !needs.includes(j));
+
+if (missing.length > 0) {
+  console.error(
+    `Missing jobs in all-tests-passed needs: ${missing.join(", ")}`,
+  );
+  console.info(
+    "Please add the missing jobs to the needs section of all-tests-passed in test.yml.",
+  );
+  process.exit(1);
+}
+console.log(
+  "All jobs in test.yml are in the needs section of all-tests-passed.",
+);

.github/workflows/check-dist.yml

@@ -1,49 +0,0 @@
-# `dist/index.js` is a special file in Actions.
-# When you reference an action with `uses:` in a workflow,
-# `index.js` is the code that will run.
-# For our project, we generate this file through a build process from other source files.
-# We need to make sure the checked-in `index.js` actually matches what we expect it to be.
-name: Check dist/
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-  workflow_dispatch:
-
-jobs:
-  check-dist:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Node.js 20
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Rebuild the dist/ directory
-        run: |
-          npm run build
-          npm run package
-
-      - 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 --text -v
-            exit 1
-          fi
-        id: diff
-
-      # If index.js was 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/codeql-analysis.yml

@@ -12,13 +12,14 @@
 name: "CodeQL"
 
 on:
+  workflow_dispatch:
   push:
-    branches: [main]
+    branches:
+      - main
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [main]
-  schedule:
-    - cron: "31 7 * * 3"
+    branches:
+      - main
 
 jobs:
   analyze:

.github/workflows/release-drafter.yml

@@ -3,15 +3,18 @@ name: Release Drafter
 
 # yamllint disable-line rule:truthy
 on:
+  workflow_dispatch:
   push:
     branches:
       - main
-  workflow_dispatch:
 
 jobs:
   update_release_draft:
     name: ✏️ Draft release
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04-arm
+    permissions:
+      contents: write
+      pull-requests: read
     steps:
       - name: 🚀 Run Release Drafter
         uses: release-drafter/release-drafter@v6.1.0

.github/workflows/test-cache-windows.yml

@@ -1,43 +0,0 @@
-name: "test-cache-windows"
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test-setup-cache:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
-      - run: uv sync
-        working-directory: __tests__\fixtures\uv-project
-  test-restore-cache:
-    runs-on: windows-latest
-    needs: test-setup-cache
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore with cache
-        id: restore
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
-      - name: Cache was hit
-        run: |
-          if ($env:CACHE_HIT -ne "true") {
-            exit 1
-          }
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - run: uv sync
-        working-directory: __tests__\fixtures\uv-project

.github/workflows/test-cache.yml

@@ -1,229 +0,0 @@
-name: "test-cache"
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test-setup-cache:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        enable-cache: [ "true", "false", "auto" ]
-        os: ["ubuntu-latest", "selfhosted-ubuntu-arm64"]
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: ${{ matrix.enable-cache }}
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-${{ matrix.os }}-${{ matrix.enable-cache }}
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-  test-restore-cache:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        enable-cache: [ "true", "false", "auto" ]
-        os: [ "ubuntu-latest", "selfhosted-ubuntu-arm64" ]
-    needs: test-setup-cache
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore with cache
-        id: restore
-        uses: ./
-        with:
-          enable-cache: ${{ matrix.enable-cache }}
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-${{ matrix.os }}-${{ matrix.enable-cache }}
-      - name: Cache was hit
-        if: ${{ matrix.enable-cache == 'true' || (matrix.enable-cache == 'auto' && matrix.os == 'ubuntu-latest') }}
-        run: |
-          if [ "$CACHE_HIT" != "true" ]; then
-            exit 1
-          fi
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - name: Cache was not hit
-        if: ${{ matrix.enable-cache == 'false' || (matrix.enable-cache == 'auto' && matrix.os == 'selfhosted-ubuntu-arm64') }}
-        run: |
-          if [ "$CACHE_HIT" == "true" ]; then
-            exit 1
-          fi
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-  test-setup-cache-requirements-txt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-requirements-txt
-      - run: |
-          uv venv
-          uv pip install -r requirements.txt
-        working-directory: __tests__/fixtures/requirements-txt-project
-  test-restore-cache-requirements-txt:
-    runs-on: ubuntu-latest
-    needs: test-setup-cache
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore with cache
-        id: restore
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-requirements-txt
-      - name: Cache was hit
-        run: |
-          if [ "$CACHE_HIT" != "true" ]; then
-            exit 1
-          fi
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - run: |
-          uv venv
-          uv pip install -r requirements.txt
-        working-directory: __tests__/fixtures/requirements-txt-project
-
-  test-setup-cache-dependency-glob:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-          cache-dependency-glob: |
-            __tests__/fixtures/uv-project/uv.lock
-            **/pyproject.toml
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-dependency-glob
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-  test-restore-cache-dependency-glob:
-    runs-on: ubuntu-latest
-    needs: test-setup-cache-dependency-glob
-    steps:
-      - uses: actions/checkout@v4
-      - name: Change pyproject.toml
-        run: |
-          echo '[tool.uv]' >> __tests__/fixtures/uv-project/pyproject.toml
-          echo 'dev-dependencies = []' >> __tests__/fixtures/uv-project/pyproject.toml
-      - name: Restore with cache
-        id: restore
-        uses: ./
-        with:
-          enable-cache: true
-          cache-dependency-glob: |
-            __tests__/fixtures/uv-project/uv.lock
-            **/pyproject.toml
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-dependency-glob
-          ignore-nothing-to-cache: true
-      - name: Cache was not hit
-        run: |
-          if [ "$CACHE_HIT" == "true" ]; then
-            exit 1
-          fi
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-
-  test-setup-cache-local:
-    runs-on: selfhosted-ubuntu-arm64
-    steps:
-      - uses: actions/checkout@v4
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-local
-          cache-local-path: /tmp/uv-cache
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-  test-restore-cache-local:
-    runs-on: selfhosted-ubuntu-arm64
-    needs: test-setup-cache-local
-    steps:
-      - uses: actions/checkout@v4
-      - name: Restore with cache
-        id: restore
-        uses: ./
-        with:
-          enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-local
-          cache-local-path: /tmp/uv-cache
-      - name: Cache was hit
-        run: |
-          if [ "$CACHE_HIT" != "true" ]; then
-            exit 1
-          fi
-        env:
-          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-
-  test-tilde-expansion-cache-local-path:
-    runs-on: selfhosted-ubuntu-arm64
-    steps:
-      - uses: actions/checkout@v4
-      - name: Create cache directory
-        run: mkdir -p ~/uv-cache
-        shell: bash
-      - name: Setup with cache
-        uses: ./
-        with:
-          cache-local-path: ~/uv-cache/cache-local-path
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-
-  test-tilde-expansion-cache-dependency-glob:
-    runs-on: selfhosted-ubuntu-arm64
-    steps:
-      - uses: actions/checkout@v4
-      - name: Create cache directory
-        run: mkdir -p ~/uv-cache
-        shell: bash
-      - name: Create cache dependency glob file
-        run: touch ~/uv-cache.glob
-        shell: bash
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-          cache-local-path: ~/uv-cache/cache-dependency-glob
-          cache-dependency-glob: "~/uv-cache.glob"
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
-
-  cleanup-tilde-expansion-tests:
-    needs:
-      - test-tilde-expansion-cache-local-path
-      - test-tilde-expansion-cache-dependency-glob
-    runs-on: selfhosted-ubuntu-arm64
-    steps:
-      - name: Remove cache directory
-        run: rm -rf ~/uv-cache
-        shell: bash
-      - name: Remove cache dependency glob file
-        run: rm -f ~/uv-cache.glob
-        shell: bash
-
-  test-no-python-version:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Fake pyproject.toml at root
-        run: cp __tests__/fixtures/old-python-constraint-project/pyproject.toml pyproject.toml
-      - name: Setup with cache
-        uses: ./
-        with:
-          enable-cache: true
-      - run: uv sync
-        working-directory: __tests__/fixtures/old-python-constraint-project

.github/workflows/test-windows.yml

@@ -1,29 +0,0 @@
-name: "test-windows"
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test-default-version:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Should not be on path
-        run: |
-          if (!(Get-Command -Name "uv" -ErrorAction SilentlyContinue)) {
-            exit 0
-          } else {
-            exit 1
-          }
-      - name: Setup uv
-        uses: ./
-        with:
-          python-version: "3.13"
-      - run: ls
-      - run: uv pip install -r __tests__/fixtures/requirements-txt-project/requirements.txt

.github/workflows/test.yml

@@ -1,6 +1,9 @@
 name: "test"
 on:
+  workflow_dispatch:
   pull_request:
+    branches:
+      - main
   push:
     branches:
       - main
@@ -9,11 +12,16 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
-  build:
+  lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - name: Actionlint
+        uses: eifinger/actionlint-action@23c85443d840cd73bbecb9cddfc933cc21649a38  # v1.9.1
       - uses: actions/setup-node@v4
         with:
           node-version: "20"
@@ -21,20 +29,33 @@ jobs:
           npm install
       - run: |
           npm run all
+      - name: Check all jobs are in all-tests-passed.needs
+        run: |
+          tsc check-all-tests-passed-needs.ts
+          node check-all-tests-passed-needs.js
+        working-directory: .github/scripts
       - name: Make sure no changes from linters are detected
         run: |
-          git diff --exit-code
+          git diff --exit-code || (echo "::error::Please run 'npm run all' to fix the issues" && exit 1)
+
   test-default-version:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, macos-14]
+        os: [ubuntu-latest, macos-latest, macos-14, windows-latest]
     steps:
       - uses: actions/checkout@v4
       - name: Install latest version
+        id: setup-uv
         uses: ./
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+        shell: bash
+      - name: Check uv-path is set
+        run: ${{ steps.setup-uv.outputs.uv-path }} --version
+      - name: Check uvx-path is set
+        run: ${{ steps.setup-uv.outputs.uvx-path }} --version
+
   test-specific-version:
     runs-on: ubuntu-latest
     strategy:
@@ -48,8 +69,12 @@ jobs:
           version: ${{ matrix.uv-version }}
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+
   test-semver-range:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, selfhosted-ubuntu-arm64 ]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
       - name: Install version 0.3
@@ -58,12 +83,35 @@ jobs:
         with:
           version: "0.3"
       - name: Correct version gets installed
+        run: |
+          if [ "$(uv --version)" != "uv 0.3.5" ]; then
+            echo "Wrong uv version: $(uv --version)"
+            exit 1
+          fi
+      - name: Output has correct version
         run: |
           if [ "$UV_VERSION" != "0.3.5" ]; then
             exit 1
           fi
         env:
           UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
+
+  test-pep440-version:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install version 0.4.30
+        id: setup-uv
+        uses: ./
+        with:
+          version: ">=0.4.25,<0.5"
+      - name: Correct version gets installed
+        run: |
+          if [ "$(uv --version)" != "uv 0.4.30" ]; then
+            echo "Wrong uv version: $(uv --version)"
+            exit 1
+          fi
+
   test-pyproject-file-version:
     runs-on: ubuntu-latest
     steps:
@@ -72,14 +120,25 @@ jobs:
         id: setup-uv
         uses: ./
         with:
-          pyproject-file: "__tests__/fixtures/pyproject-toml-project/pyproject.toml"
+          working-directory: "__tests__/fixtures/pyproject-toml-project"
       - name: Correct version gets installed
         run: |
-          if [ "$UV_VERSION" != "0.5.14" ]; then
+          if [ "$(uv --version)" != "uv 0.5.14" ]; then
+            echo "Wrong uv version: $(uv --version)"
             exit 1
           fi
-        env:
-          UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
+
+  test-malformed-pyproject-file-fallback:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install using malformed pyproject.toml
+        id: setup-uv
+        uses: ./
+        with:
+          working-directory: "__tests__/fixtures/malformed-pyproject-toml-project"
+      - run: uv --help
+
   test-uv-file-version:
     runs-on: ubuntu-latest
     steps:
@@ -88,26 +147,21 @@ jobs:
         id: setup-uv
         uses: ./
         with:
-          pyproject-file: "__tests__/fixtures/uv-toml-project/pyproject.toml"
-          uv-file: "__tests__/fixtures/uv-toml-project/uv.toml"
+          working-directory: "__tests__/fixtures/uv-toml-project"
       - name: Correct version gets installed
         run: |
-          if [ "$UV_VERSION" != "0.5.15" ]; then
+          if [ "$(uv --version)" != "uv 0.5.15" ]; then
+            echo "Wrong uv version: $(uv --version)"
             exit 1
           fi
-        env:
-          UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
+
   test-checksum:
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.inputs.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
-        checksum:
-          ["4d9279ad5ca596b1e2d703901d508430eb07564dc4d8837de9e2fca9c90f8ecd"]
-        exclude:
-          - os: macos-latest
+        inputs:
+          - os: ubuntu-latest
             checksum: "4d9279ad5ca596b1e2d703901d508430eb07564dc4d8837de9e2fca9c90f8ecd"
-        include:
           - os: macos-latest
             checksum: "a70cbfbf3bb5c08b2f84963b4f12c94e08fbb2468ba418a3bfe1066fbe9e7218"
     steps:
@@ -116,9 +170,10 @@ jobs:
         uses: ./
         with:
           version: "0.3.2"
-          checksum: ${{ matrix.checksum }}
+          checksum: ${{ matrix.inputs.checksum }}
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+
   test-with-explicit-token:
     runs-on: ubuntu-latest
     steps:
@@ -129,6 +184,7 @@ jobs:
           github-token: ${{ secrets.GITHUB_TOKEN }}
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+
   test-uvx:
     runs-on: ubuntu-latest
     steps:
@@ -136,6 +192,7 @@ jobs:
       - name: Install default version
         uses: ./
       - run: uvx ruff --version
+
   test-tool-install:
     runs-on: ${{ matrix.os }}
     strategy:
@@ -153,6 +210,7 @@ jobs:
         uses: ./
       - run: uv tool install ruff
       - run: ruff --version
+
   test-tilde-expansion-tool-dirs:
     runs-on: selfhosted-ubuntu-arm64
     steps:
@@ -172,8 +230,9 @@ jobs:
               echo "UV_TOOL_DIR does not contain /home/ubuntu/tool-dir: $UV_TOOL_DIR"
               exit 1
           fi
+
   test-python-version:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
@@ -190,8 +249,23 @@ jobs:
             exit 1
           fi
         shell: bash
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+
+  test-activate-environment:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install latest version
+        uses: ./
+        with:
+          python-version: 3.13.1t
+          activate-environment: true
       - name: Verify packages can be installed
-        run: uv pip install --python=3.13.1t pip
+        run: uv pip install pip
         shell: bash
       - name: Verify python version is correct
         run: |
@@ -201,14 +275,318 @@ jobs:
           fi
         shell: bash
 
-  test-malformed-pyproject-file-fallback:
+  test-musl:
+    runs-on: ubuntu-latest
+    container: alpine
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install latest version
+        uses: ./
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+
+  test-setup-cache:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        enable-cache: [ "true", "false", "auto" ]
+        os: [ "ubuntu-latest", "selfhosted-ubuntu-arm64", "windows-latest" ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup with cache
+        uses: ./
+        with:
+          enable-cache: ${{ matrix.enable-cache }}
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-${{ matrix.os }}-${{ matrix.enable-cache }}
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+        shell: bash
+  test-restore-cache:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        enable-cache: [ "true", "false", "auto" ]
+        os: [ "ubuntu-latest", "selfhosted-ubuntu-arm64", "windows-latest" ]
+    needs: test-setup-cache
+    steps:
+      - uses: actions/checkout@v4
+      - name: Restore with cache
+        id: restore
+        uses: ./
+        with:
+          enable-cache: ${{ matrix.enable-cache }}
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-${{ matrix.os }}-${{ matrix.enable-cache }}
+      - name: Cache was hit
+        if: ${{ matrix.enable-cache == 'true' || (matrix.enable-cache == 'auto' && matrix.os == 'ubuntu-latest') }}
+        run: |
+          if [ "$CACHE_HIT" != "true" ]; then
+            exit 1
+          fi
+        env:
+          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
+        shell: bash
+      - name: Cache was not hit
+        if: ${{ matrix.enable-cache == 'false' || (matrix.enable-cache == 'auto' && matrix.os == 'selfhosted-ubuntu-arm64') }}
+        run: |
+          if [ "$CACHE_HIT" == "true" ]; then
+            exit 1
+          fi
+        env:
+          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
+        shell: bash
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+        shell: bash
+
+  test-setup-cache-requirements-txt:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Install using malformed pyproject.toml
-        id: setup-uv
+      - name: Setup with cache
         uses: ./
         with:
-          pyproject-file: "__tests__/fixtures/malformed-pyproject-toml-project/pyproject.toml"
+          enable-cache: true
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-requirements-txt
+      - run: |
+          uv venv
+          uv pip install -r requirements.txt
+        working-directory: __tests__/fixtures/requirements-txt-project
+  test-restore-cache-requirements-txt:
+    runs-on: ubuntu-latest
+    needs: test-setup-cache
+    steps:
+      - uses: actions/checkout@v4
+      - name: Restore with cache
+        id: restore
+        uses: ./
+        with:
+          enable-cache: true
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-requirements-txt
+      - name: Cache was hit
+        run: |
+          if [ "$CACHE_HIT" != "true" ]; then
+            exit 1
+          fi
+        env:
+          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
+      - run: |
+          uv venv
+          uv pip install -r requirements.txt
+        working-directory: __tests__/fixtures/requirements-txt-project
+
+  test-setup-cache-dependency-glob:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup with cache
+        uses: ./
+        with:
+          enable-cache: true
+          cache-dependency-glob: |
+            __tests__/fixtures/uv-project/uv.lock
+            **/pyproject.toml
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-dependency-glob
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+  test-restore-cache-dependency-glob:
+    runs-on: ubuntu-latest
+    needs: test-setup-cache-dependency-glob
+    steps:
+      - uses: actions/checkout@v4
+      - name: Change pyproject.toml
+        run: |
+          echo '[tool.uv]' >> __tests__/fixtures/uv-project/pyproject.toml
+          echo 'dev-dependencies = []' >> __tests__/fixtures/uv-project/pyproject.toml
+      - name: Restore with cache
+        id: restore
+        uses: ./
+        with:
+          enable-cache: true
+          cache-dependency-glob: |
+            __tests__/fixtures/uv-project/uv.lock
+            **/pyproject.toml
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-dependency-glob
+          ignore-nothing-to-cache: true
+      - name: Cache was not hit
+        run: |
+          if [ "$CACHE_HIT" == "true" ]; then
+            exit 1
+          fi
+        env:
+          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
+
+  test-cache-local:
+    strategy:
+      matrix:
+        inputs:
+          - os: ubuntu-latest
+            expected-cache-dir: "/home/runner/work/_temp/setup-uv-cache"
+          - os: windows-latest
+            expected-cache-dir: "D:\\a\\_temp\\setup-uv-cache"
+          - os: selfhosted-ubuntu-arm64
+            expected-cache-dir: "/home/ubuntu/.cache/uv"
+    runs-on: ${{ matrix.inputs.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup with cache
+        uses: ./
+        with:
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-cache-local
+      - run: |
+          if [ "$UV_CACHE_DIR" != "${{ matrix.inputs.expected-cache-dir }}" ]; then
+            echo "UV_CACHE_DIR is not set to the expected value: $UV_CACHE_DIR"
+            exit 1
+          fi
+        shell: bash
+
+  test-setup-cache-local:
+    runs-on: selfhosted-ubuntu-arm64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup with cache
+        uses: ./
+        with:
+          enable-cache: true
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-local
+          cache-local-path: /tmp/uv-cache
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+  test-restore-cache-local:
+    runs-on: selfhosted-ubuntu-arm64
+    needs: test-setup-cache-local
+    steps:
+      - uses: actions/checkout@v4
+      - name: Restore with cache
+        id: restore
+        uses: ./
+        with:
+          enable-cache: true
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-local
+          cache-local-path: /tmp/uv-cache
+      - name: Cache was hit
+        run: |
+          if [ "$CACHE_HIT" != "true" ]; then
+            exit 1
+          fi
+        env:
+          CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+
+  test-tilde-expansion-cache-local-path:
+    runs-on: selfhosted-ubuntu-arm64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Create cache directory
+        run: mkdir -p ~/uv-cache
+        shell: bash
+      - name: Setup with cache
+        uses: ./
+        with:
+          cache-local-path: ~/uv-cache/cache-local-path
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+
+  test-tilde-expansion-cache-dependency-glob:
+    runs-on: selfhosted-ubuntu-arm64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Create cache directory
+        run: mkdir -p ~/uv-cache
+        shell: bash
+      - name: Create cache dependency glob file
+        run: touch ~/uv-cache.glob
+        shell: bash
+      - name: Setup with cache
+        uses: ./
+        with:
+          enable-cache: true
+          cache-local-path: ~/uv-cache/cache-dependency-glob
+          cache-dependency-glob: "~/uv-cache.glob"
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+
+  cleanup-tilde-expansion-tests:
+    needs:
+      - test-tilde-expansion-cache-local-path
+      - test-tilde-expansion-cache-dependency-glob
+    if: always()
+    runs-on: selfhosted-ubuntu-arm64
+    steps:
+      - name: Remove cache directory
+        run: rm -rf ~/uv-cache
+        shell: bash
+      - name: Remove cache dependency glob file
+        run: rm -f ~/uv-cache.glob
+        shell: bash
+
+  test-no-python-version:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Fake pyproject.toml at root
+        run: cp __tests__/fixtures/old-python-constraint-project/pyproject.toml pyproject.toml
+      - name: Setup with cache
+        uses: ./
+        with:
+          enable-cache: true
+      - run: uv sync
+        working-directory: __tests__/fixtures/old-python-constraint-project
+
+  test-custom-manifest-file:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install from custom manifest file
+        uses: ./
+        with:
+          manifest-file: "https://raw.githubusercontent.com/astral-sh/setup-uv/${{ github.ref }}/__tests__/download/custom-manifest.json"
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
+      - name: Correct version gets installed
+        run: |
+          if [ "$(uv --version)" != "uv 0.7.12-alpha.1" ]; then
+            echo "Wrong uv version: $(uv --version)"
+            exit 1
+          fi
+
+  all-tests-passed:
+    runs-on: ubuntu-latest
+    needs:
+      - lint
+      - test-default-version
+      - test-specific-version
+      - test-semver-range
+      - test-pep440-version
+      - test-pyproject-file-version
+      - test-malformed-pyproject-file-fallback
+      - test-uv-file-version
+      - test-checksum
+      - test-with-explicit-token
+      - test-uvx
+      - test-tool-install
+      - test-tilde-expansion-tool-dirs
+      - test-python-version
+      - test-activate-environment
+      - test-musl
+      - test-cache-local
+      - test-setup-cache
+      - test-restore-cache
+      - test-setup-cache-requirements-txt
+      - test-restore-cache-requirements-txt
+      - test-setup-cache-dependency-glob
+      - test-restore-cache-dependency-glob
+      - test-setup-cache-local
+      - test-restore-cache-local
+      - test-tilde-expansion-cache-local-path
+      - test-tilde-expansion-cache-dependency-glob
+      - cleanup-tilde-expansion-tests
+      - test-no-python-version
+      - test-custom-manifest-file
+    if: always()
+    steps:
+      - name: All tests passed
+        run: |
+          echo "All jobs passed: ${{ !contains(needs.*.result, 'failure') }}"
+          # shellcheck disable=SC2242
+          exit ${{ contains(needs.*.result, 'failure') && 1 || 0 }}

.github/workflows/update-known-checksums.yml

@@ -1,34 +0,0 @@
-name: "Update known checksums"
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 4 * * *" # Run every day at 4am UTC
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-      - name: Update known checksums
-        id: update-known-checksums
-        run:
-          node dist/update-known-checksums/index.js
-          src/download/checksum/known-checksums.ts ${{ secrets.GITHUB_TOKEN }}
-      - run: npm install && npm run all
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@67ccf781d68cd99b580ae25a5c18a1cc84ffff1f # v7.0.6
-        with:
-          commit-message: "chore: update known checksums"
-          title:
-            "chore: update known checksums for ${{
-            steps.update-known-checksums.outputs.latest-version }}"
-          body:
-            "chore: update known checksums for ${{
-            steps.update-known-checksums.outputs.latest-version }}"
-          base: main
-          labels: "automated-pr,update-known-checksums"
-          branch: update-known-checksums-pr
-          delete-branch: true

.github/workflows/update-known-versions.yml

@@ -0,0 +1,39 @@
+name: "Update known versions"
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 4 * * *" # Run every day at 4am UTC
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04-arm
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - name: Update known versions
+        id: update-known-versions
+        run:
+          node dist/update-known-versions/index.js
+          src/download/checksum/known-checksums.ts
+          version-manifest.json
+          ${{ secrets.GITHUB_TOKEN }}
+      - run: npm install && npm run all
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b9829c1cb33d45e # v7.0.8
+        with:
+          commit-message: "chore: update known versions"
+          title:
+            "chore: update known versions for ${{
+            steps.update-known-versions.outputs.latest-version }}"
+          body:
+            "chore: update known versions for ${{
+            steps.update-known-versions.outputs.latest-version }}"
+          base: main
+          labels: "automated-pr,update-known-versions"
+          branch: update-known-versions-pr
+          delete-branch: true

.github/workflows/update-major-minor-tags.yml

@@ -1,7 +1,6 @@
 ---
 name: Update Major Minor Tags
 
-# yamllint disable-line rule:truthy
 on:
   push:
     branches-ignore:
@@ -12,8 +11,37 @@ on:
 jobs:
   update_major_minor_tags:
     name: Make sure major and minor tags are up to date on a patch release
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04-arm
+    permissions:
+      contents: write
     steps:
       - uses: actions/checkout@v4
-      - name: Run Update semver
-        uses: haya14busa/action-update-semver@v1.2.1
+      - name: Update Major Minor Tags
+        run: |
+          set -x
+
+          cd "${GITHUB_WORKSPACE}" || exit
+
+          # Set up variables.
+          TAG="${GITHUB_REF#refs/tags/}" # v1.2.3
+          MINOR="${TAG%.*}"              # v1.2
+          MAJOR="${MINOR%.*}"            # v1
+
+          if [ "${GITHUB_REF}" = "${TAG}" ]; then
+            echo "This workflow is not triggered by tag push: GITHUB_REF=${GITHUB_REF}"
+            exit 1
+          fi
+
+          MESSAGE="Release ${TAG}"
+
+          # Set up Git.
+          git config user.name "${GITHUB_ACTOR}"
+          git config user.email "${GITHUB_ACTOR}@users.noreply.github.com"
+
+          # Update MAJOR/MINOR tag
+          git tag -fa "${MAJOR}" -m "${MESSAGE}"
+          git tag -fa "${MINOR}" -m "${MESSAGE}"
+
+          # Push
+          git push --force origin "${MINOR}"
+          git push --force origin "${MAJOR}"

README.md

@@ -14,9 +14,10 @@ Set up your GitHub Actions workflow with a specific version of [uv](https://docs
   - [Install a required-version or latest (default)](#install-a-required-version-or-latest-default)
   - [Install the latest version](#install-the-latest-version)
   - [Install a specific version](#install-a-specific-version)
-  - [Install a version by supplying a semver range](#install-a-version-by-supplying-a-semver-range)
-  - [Install a required-version](#install-a-required-version)
+  - [Install a version by supplying a semver range or pep440 specifier](#install-a-version-by-supplying-a-semver-range-or-pep440-specifier)
   - [Python version](#python-version)
+  - [Activate environment](#activate-environment)
+  - [Working directory](#working-directory)
   - [Validate checksum](#validate-checksum)
   - [Enable Caching](#enable-caching)
     - [Cache dependency glob](#cache-dependency-glob)
@@ -27,6 +28,7 @@ Set up your GitHub Actions workflow with a specific version of [uv](https://docs
   - [UV_TOOL_DIR](#uv_tool_dir)
   - [UV_TOOL_BIN_DIR](#uv_tool_bin_dir)
   - [Tilde Expansion](#tilde-expansion)
+  - [Manifest file](#manifest-file)
 - [How it works](#how-it-works)
 - [FAQ](#faq)
 
@@ -36,7 +38,7 @@ Set up your GitHub Actions workflow with a specific version of [uv](https://docs
 
 ```yaml
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
 ```
 
 If you do not specify a version, this action will look for a [required-version](https://docs.astral.sh/uv/reference/settings/#required-version)
@@ -49,7 +51,7 @@ For an example workflow, see
 
 ```yaml
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     version: "latest"
 ```
@@ -58,62 +60,47 @@ For an example workflow, see
 
 ```yaml
 - name: Install a specific version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     version: "0.4.4"
 ```
 
-### Install a version by supplying a semver range
+### Install a version by supplying a semver range or pep440 specifier
 
 You can specify a [semver range](https://github.com/npm/node-semver?tab=readme-ov-file#ranges)
+or [pep440 specifier](https://peps.python.org/pep-0440/#version-specifiers)
 to install the latest version that satisfies the range.
 
 ```yaml
 - name: Install a semver range of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     version: ">=0.4.0"
 ```
 
 ```yaml
 - name: Pinning a minor version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     version: "0.4.x"
 ```
 
-### Install a required-version
-
-You can specify a [required-version](https://docs.astral.sh/uv/reference/settings/#required-version)
-in either a `uv.toml` or `pyproject.toml` file:
-
 ```yaml
-- name: Install required-version defined in uv.toml
-  uses: astral-sh/setup-uv@v5
+- name: Install a pep440-specifier-satisfying version of uv
+  uses: astral-sh/setup-uv@v6
   with:
-    uv-file: "path/to/uv.toml"
-```
-
-```yaml
-- name: Install required-version defined in pyproject.toml
-  uses: astral-sh/setup-uv@v5
-  with:
-    pyproject-file: "path/to/pyproject.toml"
+    version: ">=0.4.25,<0.5"
 ```
 
 ### Python version
 
-You can use the input `python-version` to
-
-- set the environment variable `UV_PYTHON` for the rest of your workflow
-- create a new virtual environment with the specified python version
-- activate the virtual environment for the rest of your workflow
+You can use the input `python-version` to set the environment variable `UV_PYTHON` for the rest of your workflow
 
 This will override any python version specifications in `pyproject.toml` and `.python-version`
 
 ```yaml
 - name: Install the latest version of uv and set the python version to 3.13t
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     python-version: 3.13t
 - run: uv pip install --python=3.13t pip
@@ -131,13 +118,51 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install the latest version of uv and set the python version
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Test with python ${{ matrix.python-version }}
         run: uv run --frozen pytest
 ```
 
+### Activate environment
+
+You can set `activate-environment` to `true` to automatically activate a venv.
+This allows directly using it in later steps:
+
+```yaml
+- name: Install the latest version of uv and activate the environment
+  uses: astral-sh/setup-uv@v6
+  with:
+    activate-environment: true
+- run: uv pip install pip
+```
+
+> [!WARNING]
+>
+> Activating the environment adds your dependencies to the `PATH`, which could break some workflows.
+> For example, if you have a dependency which requires uv, e.g., `hatch`, activating the
+> environment will shadow the `uv` binary installed by this action and may result in a different uv
+> version being used.
+>
+> We do not recommend using this setting for most use-cases. Instead, use `uv run` to execute
+> commands in the environment.
+
+### Working directory
+
+You can set the working directory with the `working-directory` input.
+This controls where we look for `pyproject.toml`, `uv.toml` and `.python-version` files
+which are used to determine the version of uv and python to install.
+
+It also controls where [the venv gets created](#activate-environment).
+
+```yaml
+- name: Install uv based on the config files in the working-directory
+  uses: astral-sh/setup-uv@v6
+  with:
+    working-directory: my/subproject/dir
+```
+
 ### Validate checksum
 
 You can specify a checksum to validate the downloaded executable. Checksums up to the default version
@@ -146,7 +171,7 @@ are automatically verified by this action. The sha256 hashes can be found on the
 
 ```yaml
 - name: Install a specific version and validate the checksum
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     version: "0.3.1"
     checksum: "e11b01402ab645392c7ad6044db63d37e4fd1e745e015306993b07695ea5f9f8"
@@ -156,6 +181,7 @@ are automatically verified by this action. The sha256 hashes can be found on the
 
 If you enable caching, the [uv cache](https://docs.astral.sh/uv/concepts/cache/) will be uploaded to
 the GitHub Actions cache. This can speed up runs that reuse the cache by several minutes.
+Caching is enabled by default on GitHub-hosted runners.
 
 > [!TIP]
 >
@@ -167,7 +193,7 @@ You can optionally define a custom cache key suffix.
 ```yaml
 - name: Enable caching and define a custom cache key suffix
   id: setup-uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     cache-suffix: "optional-suffix"
@@ -190,16 +216,22 @@ changes. If you use relative paths, they are relative to the repository root.
 
 > [!NOTE]
 >
+> You can look up supported patterns [here](https://github.com/actions/toolkit/tree/main/packages/glob#patterns)
+>
 > The default is
 > ```yaml
 > cache-dependency-glob: |
->   **/requirements*.txt
+>   **/*requirements*.txt
+>   **/*requirements*.in
+>   **/*constraints*.txt
+>   **/*constraints*.in
+>   **/pyproject.toml
 >   **/uv.lock
 > ```
 
 ```yaml
 - name: Define a cache dependency glob
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     cache-dependency-glob: "**/pyproject.toml"
@@ -207,7 +239,7 @@ changes. If you use relative paths, they are relative to the repository root.
 
 ```yaml
 - name: Define a list of cache dependency globs
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     cache-dependency-glob: |
@@ -217,7 +249,7 @@ changes. If you use relative paths, they are relative to the repository root.
 
 ```yaml
 - name: Define an absolute cache dependency glob
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     cache-dependency-glob: "/tmp/my-folder/requirements*.txt"
@@ -225,7 +257,7 @@ changes. If you use relative paths, they are relative to the repository root.
 
 ```yaml
 - name: Never invalidate the cache
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     cache-dependency-glob: ""
@@ -240,7 +272,7 @@ It defaults to `setup-uv-cache` in the `TMP` dir, `D:\a\_temp\uv-tool-dir` on Wi
 
 ```yaml
 - name: Define a custom uv cache path
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     cache-local-path: "/path/to/cache"
 ```
@@ -259,7 +291,7 @@ input.
 
 ```yaml
 - name: Don't prune the cache before saving it
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     prune-cache: false
@@ -272,12 +304,26 @@ If you want to ignore this, set the `ignore-nothing-to-cache` input to `true`.
 
 ```yaml
 - name: Ignore nothing to cache
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
     ignore-nothing-to-cache: true
 ```
 
+### Ignore empty workdir
+
+By default, the action will warn if the workdir is empty, because this is usually the case when
+`actions/checkout` is configured to run after `setup-uv`, which is not supported.
+
+If you want to ignore this, set the `ignore-empty-workdir` input to `true`.
+
+```yaml
+- name: Ignore empty workdir
+  uses: astral-sh/setup-uv@v6
+  with:
+    ignore-empty-workdir: true
+```
+
 ### GitHub authentication token
 
 This action uses the GitHub API to fetch the uv release artifacts. To avoid hitting the GitHub API
@@ -290,7 +336,7 @@ are not sufficient, you can provide a custom GitHub token with the necessary per
 
 ```yaml
 - name: Install the latest version of uv with a custom GitHub token
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     github-token: ${{ secrets.CUSTOM_GITHUB_TOKEN }}
 ```
@@ -308,7 +354,7 @@ input:
 
 ```yaml
 - name: Install the latest version of uv with a custom tool dir
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     tool-dir: "/path/to/tool/dir"
 ```
@@ -327,7 +373,7 @@ If you want to change this behaviour (especially on self-hosted runners) you can
 
 ```yaml
 - name: Install the latest version of uv with a custom tool bin dir
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     tool-bin-dir: "/path/to/tool-bin/dir"
 ```
@@ -343,7 +389,7 @@ This action supports expanding the `~` character to the user's home directory fo
 
 ```yaml
 - name: Expand the tilde character
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     cache-local-path: "~/path/to/cache"
     tool-dir: "~/path/to/tool/dir"
@@ -351,6 +397,44 @@ This action supports expanding the `~` character to the user's home directory fo
     cache-dependency-glob: "~/my-cache-buster"
 ```
 
+### Manifest file
+
+The `manifest-file` input allows you to specify a JSON manifest that lists available uv versions,
+architectures, and their download URLs. By default, this action uses the manifest file contained
+in this repository, which is automatically updated with each release of uv.
+
+The manifest file contains an array of objects, each describing a version,
+architecture, platform, and the corresponding download URL. For example:
+
+```json
+[
+  {
+    "version": "0.7.13",
+    "artifactName": "uv-aarch64-apple-darwin.tar.gz",
+    "arch": "aarch64",
+    "platform": "apple-darwin",
+    "downloadUrl": "https://github.com/astral-sh/uv/releases/download/0.7.13/uv-aarch64-apple-darwin.tar.gz"
+  },
+  ...
+]
+```
+
+You can supply a custom manifest file URL to define additional versions,
+architectures, or different download URLs.
+This is useful if you maintain your own uv builds or want to override the default sources.
+
+```yaml
+- name: Use a custom manifest file
+  uses: astral-sh/setup-uv@v6
+  with:
+    manifest-file: "https://example.com/my-custom-manifest.json"
+```
+
+> [!NOTE]
+> When you use a custom manifest file and do not set the `version` input, its default value is `latest`.
+> This means the action will install the latest version available in the custom manifest file.
+> This is different from the default behavior of installing the latest version from the official uv releases.
+
 ## How it works
 
 This action downloads uv from the uv repo's official
@@ -358,7 +442,7 @@ This action downloads uv from the uv repo's official
 [GitHub Actions Toolkit](https://github.com/actions/toolkit) to cache it as a tool to speed up
 consecutive runs on self-hosted runners.
 
-The installed version of uv is then added to the runner PATH, enabling subsequent steps to invoke it
+The installed version of uv is then added to the runner PATH, enabling later steps to invoke it
 by name (`uv`).
 
 ## FAQ
@@ -376,7 +460,7 @@ For example:
 - name: Checkout the repository
   uses: actions/checkout@main
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
 - name: Test
@@ -388,7 +472,7 @@ To install a specific version of Python, use
 
 ```yaml
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
   with:
     enable-cache: true
 - name: Install Python 3.12
@@ -407,11 +491,57 @@ output:
   uses: actions/checkout@main
 - name: Install the default version of uv
   id: setup-uv
-  uses: astral-sh/setup-uv@v5
+  uses: astral-sh/setup-uv@v6
 - name: Print the installed version
   run: echo "Installed uv version is ${{ steps.setup-uv.outputs.uv-version }}"
 ```
 
+### Should I include the resolution strategy in the cache key?
+
+**Yes!**
+
+The cache key gets computed by using the [cache-dependency-glob](#cache-dependency-glob).
+
+If you
+have jobs which use the same dependency definitions from `requirements.txt` or
+`pyproject.toml` but different
+[resolution strategies](https://docs.astral.sh/uv/concepts/resolution/#resolution-strategy),
+each job will have different dependencies or dependency versions.
+But if you do not add the resolution strategy as a [cache-suffix](#enable-caching),
+they will have the same cache key.
+
+This means the first job which starts uploading its cache will win and all other job will fail
+uploading the cache,
+because they try to upload with the same cache key.
+
+You might see errors like
+`Failed to save: Failed to CreateCacheEntry: Received non-retryable error: Failed request: (409) Conflict: cache entry with the same key, version, and scope already exists`
+
+### Why do I see warnings like `No GitHub Actions cache found for key`
+
+When a workflow runs for the first time on a branch and has a new cache key, because the
+[cache-dependency-glob](#cache-dependency-glob) found changed files (changed dependencies),
+the cache will not be found and the warning `No GitHub Actions cache found for key` will be printed.
+
+While this might be irritating at first, it is expected behaviour and the cache will be created
+and reused in later workflows.
+
+The reason for the warning is, that we have to way to know if this is the first run of a new
+cache key or the user accidentally misconfigured the [cache-dependency-glob](#cache-dependency-glob)
+or [cache-suffix](#enable-caching) and the cache never gets used.
+
+### Do I have to run `actions/checkout` before or after `setup-uv`?
+
+Some workflows need uv but do not need to access the repository content.
+
+But **if** you need to access the repository content, you have run `actions/checkout` before running `setup-uv`.
+Running `actions/checkout` after `setup-uv` **is not supported**.
+
+### Does `setup-uv` also install my project or its dependencies automatically?
+
+No, `setup-uv` alone wont install any libraries from your `pyproject.toml` or `requirements.txt`, it only sets up `uv`.
+You should run `uv sync` or `uv pip install .` separately, or use `uv run ...` to ensure necessary dependencies are installed.
+
 ## Acknowledgements
 
 `setup-uv` was initially written and published by [Kevin Stillhammer](https://github.com/eifinger)

__tests__/download/custom-manifest.json

@@ -0,0 +1,9 @@
+[
+  {
+    "version": "0.7.12-alpha.1",
+    "artifactName": "uv-x86_64-unknown-linux-gnu.tar.gz",
+    "arch": "x86_64",
+    "platform": "unknown-linux-gnu",
+    "downloadUrl": "https://release.pyx.dev/0.7.12-alpha.1/uv-x86_64-unknown-linux-gnu.tar.gz"
+  }
+]

action.yml

@@ -6,18 +6,22 @@ inputs:
   version:
     description: "The version of uv to install e.g., `0.5.0` Defaults to the version in pyproject.toml or 'latest'."
     default: ""
-  pyproject-file:
-    description: "Path to a pyproject.toml"
-    default: ""
-  uv-file:
-    description: "Path to a uv.toml"
-    default: ""
   python-version:
     description: "The version of Python to set UV_PYTHON to"
     required: false
+  activate-environment:
+    description: "Use uv venv to activate a venv ready to be used by later steps. "
+    default: "false"
+  working-directory:
+    description: "The directory to execute all commands in and look for files such as pyproject.toml"
+    default: ${{ github.workspace }}
   checksum:
     description: "The checksum of the uv version to install"
     required: false
+  server-url:
+    description: "(Deprecated) The server url to use when downloading uv"
+    required: false
+    default: "https://github.com"
   github-token:
     description:
       "Used to increase the rate limit when retrieving versions and downloading uv."
@@ -31,8 +35,12 @@ inputs:
       "Glob pattern to match files relative to the repository root to control
       the cache."
     default: |
+      **/*requirements*.txt
+      **/*requirements*.in
+      **/*constraints*.txt
+      **/*constraints*.in
+      **/pyproject.toml
       **/uv.lock
-      **/requirements*.txt
   cache-suffix:
     description: "Suffix for the cache key"
     required: false
@@ -45,15 +53,25 @@ inputs:
   ignore-nothing-to-cache:
     description: "Ignore when nothing is found to cache."
     default: "false"
+  ignore-empty-workdir:
+    description: "Ignore when the working directory is empty."
+    default: "false"
   tool-dir:
     description: "Custom path to set UV_TOOL_DIR to."
     required: false
   tool-bin-dir:
     description: "Custom path to set UV_TOOL_BIN_DIR to."
     required: false
+  manifest-file:
+    description: "URL to the manifest file containing available versions and download URLs."
+    required: false
 outputs:
   uv-version:
     description: "The installed uv version. Useful when using latest."
+  uv-path:
+    description: "The path to the installed uv binary."
+  uvx-path:
+    description: "The path to the installed uvx binary."
   cache-hit:
     description: "A boolean value to indicate a cache entry was found"
 runs:

package.json

@@ -9,10 +9,10 @@
     "format": "biome format --fix",
     "format-check": "biome format",
     "lint": "biome lint --fix",
-    "package": "ncc build -o dist/setup src/setup-uv.ts && ncc build -o dist/save-cache src/save-cache.ts && ncc build -o dist/update-known-checksums src/update-known-checksums.ts",
+    "package": "ncc build -o dist/setup src/setup-uv.ts && ncc build -o dist/save-cache src/save-cache.ts && ncc build -o dist/update-known-versions src/update-known-versions.ts",
     "test": "jest",
     "act": "act pull_request -W .github/workflows/test.yml --container-architecture linux/amd64 -s GITHUB_TOKEN=\"$(gh auth token)\"",
-    "update-known-checksums": "RUNNER_TEMP=known_checksums node dist/update-known-checksums/index.js src/download/checksum/known-checksums.ts \"$(gh auth token)\"",
+    "update-known-versions": "RUNNER_TEMP=known_versions node dist/update-known-versions/index.js src/download/checksum/known-versions.ts \"$(gh auth token)\"",
     "all": "npm run build && npm run format && npm run lint && npm run package && npm test"
   },
   "repository": {
@@ -23,25 +23,28 @@
   "author": "@eifinger",
   "license": "MIT",
   "dependencies": {
-    "@actions/cache": "^4.0.0",
+    "@actions/cache": "^4.0.3",
     "@actions/core": "^1.11.1",
     "@actions/exec": "^1.1.1",
     "@actions/glob": "^0.5.0",
     "@actions/io": "^1.1.3",
     "@actions/tool-cache": "^2.0.2",
-    "@octokit/core": "^6.1.3",
-    "@octokit/plugin-paginate-rest": "^11.4.0",
-    "@octokit/plugin-rest-endpoint-methods": "^13.3.0",
-    "smol-toml": "^1.3.1"
+    "@octokit/core": "^7.0.2",
+    "@octokit/plugin-paginate-rest": "^12.0.0",
+    "@octokit/plugin-rest-endpoint-methods": "^14.0.0",
+    "@renovatebot/pep440": "^4.1.0",
+    "smol-toml": "^1.3.4",
+    "undici": "^7.10.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "@types/node": "^22.12.0",
-    "@types/semver": "^7.5.8",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.15.21",
+    "@types/semver": "^7.7.0",
     "@vercel/ncc": "^0.38.3",
     "jest": "^29.7.0",
     "js-yaml": "^4.1.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.3"
+    "ts-jest": "^29.3.2",
+    "typescript": "^5.8.3"
   }
 }

src/cache/restore-cache.ts

@@ -4,7 +4,9 @@ import {
   cacheDependencyGlob,
   cacheLocalPath,
   cacheSuffix,
+  pruneCache,
   pythonVersion as pythonVersionInput,
+  workingDirectory,
 } from "../utils/inputs";
 import { getArch, getPlatform } from "../utils/platforms";
 import { hashFiles } from "../hash/hash-files";
@@ -53,7 +55,9 @@ async function computeKeys(): Promise<string> {
   }
   const suffix = cacheSuffix ? `-${cacheSuffix}` : "";
   const pythonVersion = await getPythonVersion();
-  return `setup-uv-${CACHE_VERSION}-${getArch()}-${getPlatform()}-${pythonVersion}${cacheDependencyPathHash}${suffix}`;
+  const platform = await getPlatform();
+  const pruned = pruneCache ? "-pruned" : "";
+  return `setup-uv-${CACHE_VERSION}-${getArch()}-${platform}-${pythonVersion}${pruned}${cacheDependencyPathHash}${suffix}`;
 }
 
 async function getPythonVersion(): Promise<string> {
@@ -72,7 +76,7 @@ async function getPythonVersion(): Promise<string> {
   };
 
   try {
-    const execArgs = ["python", "find"];
+    const execArgs = ["python", "find", "--directory", workingDirectory];
     await exec.exec("uv", execArgs, options);
     const pythonPath = output.trim();
 

src/download/download-version.ts

@@ -1,15 +1,16 @@
 import * as core from "@actions/core";
 import * as tc from "@actions/tool-cache";
 import * as path from "node:path";
+import * as pep440 from "@renovatebot/pep440";
 import { promises as fs } from "node:fs";
 import { OWNER, REPO, TOOL_CACHE_NAME } from "../utils/constants";
 import type { Architecture, Platform } from "../utils/platforms";
 import { validateChecksum } from "./checksum/checksum";
-import { Octokit } from "@octokit/core";
-import { paginateRest } from "@octokit/plugin-paginate-rest";
-import { restEndpointMethods } from "@octokit/plugin-rest-endpoint-methods";
-
-const PaginatingOctokit = Octokit.plugin(paginateRest, restEndpointMethods);
+import { Octokit } from "../utils/octokit";
+import {
+  getDownloadUrl,
+  getLatestKnownVersion as getLatestVersionInManifest,
+} from "./version-manifest";
 
 export function tryGetFromToolCache(
   arch: Architecture,
@@ -26,36 +27,85 @@ export function tryGetFromToolCache(
   return { version: resolvedVersion, installedPath };
 }
 
-export async function downloadVersion(
+export async function downloadVersionFromGithub(
+  serverUrl: string,
   platform: Platform,
   arch: Architecture,
   version: string,
   checkSum: string | undefined,
   githubToken: string,
 ): Promise<{ version: string; cachedToolDir: string }> {
-  const resolvedVersion = await resolveVersion(version, githubToken);
   const artifact = `uv-${arch}-${platform}`;
-  let extension = ".tar.gz";
-  if (platform === "pc-windows-msvc") {
-    extension = ".zip";
-  }
-  const downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/download/${resolvedVersion}/${artifact}${extension}`;
-  core.info(`Downloading uv from "${downloadUrl}" ...`);
+  const extension = getExtension(platform);
+  const downloadUrl = `${serverUrl}/${OWNER}/${REPO}/releases/download/${version}/${artifact}${extension}`;
+  return await downloadVersion(
+    downloadUrl,
+    artifact,
+    platform,
+    arch,
+    version,
+    checkSum,
+    githubToken,
+  );
+}
 
+export async function downloadVersionFromManifest(
+  manifestUrl: string | undefined,
+  platform: Platform,
+  arch: Architecture,
+  version: string,
+  checkSum: string | undefined,
+  githubToken: string,
+): Promise<{ version: string; cachedToolDir: string }> {
+  const downloadUrl = await getDownloadUrl(
+    manifestUrl,
+    version,
+    arch,
+    platform,
+  );
+  if (!downloadUrl) {
+    core.info(
+      `manifest-file does not contain version ${version}, arch ${arch}, platform ${platform}. Falling back to GitHub releases.`,
+    );
+    return await downloadVersionFromGithub(
+      "https://github.com",
+      platform,
+      arch,
+      version,
+      checkSum,
+      githubToken,
+    );
+  }
+  return await downloadVersion(
+    downloadUrl,
+    `uv-${arch}-${platform}`,
+    platform,
+    arch,
+    version,
+    checkSum,
+    githubToken,
+  );
+}
+
+async function downloadVersion(
+  downloadUrl: string,
+  artifactName: string,
+  platform: Platform,
+  arch: Architecture,
+  version: string,
+  checkSum: string | undefined,
+  githubToken: string,
+): Promise<{ version: string; cachedToolDir: string }> {
+  core.info(`Downloading uv from "${downloadUrl}" ...`);
   const downloadPath = await tc.downloadTool(
     downloadUrl,
     undefined,
     githubToken,
   );
-  await validateChecksum(
-    checkSum,
-    downloadPath,
-    arch,
-    platform,
-    resolvedVersion,
-  );
+  await validateChecksum(checkSum, downloadPath, arch, platform, version);
 
   let uvDir: string;
+  const extension = getExtension(platform);
   if (platform === "pc-windows-msvc") {
     const fullPathWithExtension = `${downloadPath}${extension}`;
     await fs.copyFile(downloadPath, fullPathWithExtension);
@@ -63,32 +113,47 @@ export async function downloadVersion(
     // On windows extracting the zip does not create an intermediate directory
   } else {
     const extractedDir = await tc.extractTar(downloadPath);
-    uvDir = path.join(extractedDir, artifact);
+    uvDir = path.join(extractedDir, artifactName);
   }
   const cachedToolDir = await tc.cacheDir(
     uvDir,
     TOOL_CACHE_NAME,
-    resolvedVersion,
+    version,
     arch,
   );
-  return { version: resolvedVersion, cachedToolDir };
+  return { version: version, cachedToolDir };
+}
+
+function getExtension(platform: Platform): string {
+  return platform === "pc-windows-msvc" ? ".zip" : ".tar.gz";
 }
 
 export async function resolveVersion(
   versionInput: string,
+  manifestFile: string | undefined,
   githubToken: string,
 ): Promise<string> {
-  const version =
-    versionInput === "latest"
-      ? await getLatestVersion(githubToken)
-      : versionInput;
+  core.debug(`Resolving version: ${versionInput}`);
+  let version: string;
+  if (manifestFile) {
+    version =
+      versionInput === "latest"
+        ? await getLatestVersionInManifest(manifestFile)
+        : versionInput;
+  } else {
+    version =
+      versionInput === "latest"
+        ? await getLatestVersion(githubToken)
+        : versionInput;
+  }
   if (tc.isExplicitVersion(version)) {
     core.debug(`Version ${version} is an explicit version.`);
     return version;
   }
   const availableVersions = await getAvailableVersions(githubToken);
-  const resolvedVersion = tc.evaluateVersions(availableVersions, version);
-  if (resolvedVersion === "") {
+  core.debug(`Available versions: ${availableVersions}`);
+  const resolvedVersion = maxSatisfying(availableVersions, version);
+  if (resolvedVersion === undefined) {
     throw new Error(`No version found for ${version}`);
   }
   return resolvedVersion;
@@ -96,7 +161,7 @@ export async function resolveVersion(
 
 async function getAvailableVersions(githubToken: string): Promise<string[]> {
   try {
-    const octokit = new PaginatingOctokit({
+    const octokit = new Octokit({
       auth: githubToken,
     });
     return await getReleaseTagNames(octokit);
@@ -105,7 +170,7 @@ async function getAvailableVersions(githubToken: string): Promise<string[]> {
       core.info(
         "No (valid) GitHub token provided. Falling back to anonymous. Requests might be rate limited.",
       );
-      const octokit = new PaginatingOctokit();
+      const octokit = new Octokit();
       return await getReleaseTagNames(octokit);
     }
     throw err;
@@ -113,7 +178,7 @@ async function getAvailableVersions(githubToken: string): Promise<string[]> {
 }
 
 async function getReleaseTagNames(
-  octokit: InstanceType<typeof PaginatingOctokit>,
+  octokit: InstanceType<typeof Octokit>,
 ): Promise<string[]> {
   const response = await octokit.paginate(octokit.rest.repos.listReleases, {
     owner: OWNER,
@@ -123,7 +188,8 @@ async function getReleaseTagNames(
 }
 
 async function getLatestVersion(githubToken: string) {
-  const octokit = new PaginatingOctokit({
+  core.debug("Getting latest version...");
+  const octokit = new Octokit({
     auth: githubToken,
   });
 
@@ -131,29 +197,46 @@ async function getLatestVersion(githubToken: string) {
   try {
     latestRelease = await getLatestRelease(octokit);
   } catch (err) {
-    if ((err as Error).message.includes("Bad credentials")) {
-      core.info(
-        "No (valid) GitHub token provided. Falling back to anonymous. Requests might be rate limited.",
-      );
-      const octokit = new PaginatingOctokit();
-      latestRelease = await getLatestRelease(octokit);
-    } else {
-      throw err;
+    core.info(
+      "No (valid) GitHub token provided. Falling back to anonymous. Requests might be rate limited.",
+    );
+    if (err instanceof Error) {
+      core.debug(err.message);
     }
+    const octokit = new Octokit();
+    latestRelease = await getLatestRelease(octokit);
   }
 
   if (!latestRelease) {
     throw new Error("Could not determine latest release.");
   }
+  core.debug(`Latest version: ${latestRelease.tag_name}`);
   return latestRelease.tag_name;
 }
 
-async function getLatestRelease(
-  octokit: InstanceType<typeof PaginatingOctokit>,
-) {
+async function getLatestRelease(octokit: InstanceType<typeof Octokit>) {
   const { data: latestRelease } = await octokit.rest.repos.getLatestRelease({
     owner: OWNER,
     repo: REPO,
   });
   return latestRelease;
 }
+
+function maxSatisfying(
+  versions: string[],
+  version: string,
+): string | undefined {
+  const maxSemver = tc.evaluateVersions(versions, version);
+  if (maxSemver !== "") {
+    core.debug(`Found a version that satisfies the semver range: ${maxSemver}`);
+    return maxSemver;
+  }
+  const maxPep440 = pep440.maxSatisfying(versions, version);
+  if (maxPep440 !== null) {
+    core.debug(
+      `Found a version that satisfies the pep440 specifier: ${maxPep440}`,
+    );
+    return maxPep440;
+  }
+  return undefined;
+}

src/download/version-manifest.ts

@@ -0,0 +1,91 @@
+import { promises as fs } from "node:fs";
+import * as core from "@actions/core";
+import * as semver from "semver";
+import { fetch } from "../utils/fetch";
+import { join } from "node:path";
+
+const localManifestFile = join(__dirname, "..", "..", "version-manifest.json");
+
+interface ManifestEntry {
+  version: string;
+  artifactName: string;
+  arch: string;
+  platform: string;
+  downloadUrl: string;
+}
+
+export async function getLatestKnownVersion(
+  manifestUrl: string | undefined,
+): Promise<string> {
+  const manifestEntries = await getManifestEntries(manifestUrl);
+  return manifestEntries.reduce((a, b) =>
+    semver.gt(a.version, b.version) ? a : b,
+  ).version;
+}
+
+export async function getDownloadUrl(
+  manifestUrl: string | undefined,
+  version: string,
+  arch: string,
+  platform: string,
+): Promise<string | undefined> {
+  const manifestEntries = await getManifestEntries(manifestUrl);
+  const entry = manifestEntries.find(
+    (entry) =>
+      entry.version === version &&
+      entry.arch === arch &&
+      entry.platform === platform,
+  );
+  return entry ? entry.downloadUrl : undefined;
+}
+
+async function getManifestEntries(
+  manifestUrl: string | undefined,
+): Promise<ManifestEntry[]> {
+  let data: string;
+  if (manifestUrl !== undefined) {
+    core.info(`Fetching manifest-file from: ${manifestUrl}`);
+    const response = await fetch(manifestUrl, {});
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch manifest-file: ${response.status} ${response.statusText}`,
+      );
+    }
+    data = await response.text();
+  } else {
+    core.info("manifest-file not provided, reading from local file.");
+    const fileContent = await fs.readFile(localManifestFile);
+    data = fileContent.toString();
+  }
+
+  return JSON.parse(data);
+}
+
+export async function updateVersionManifest(
+  manifestUrl: string,
+  downloadUrls: string[],
+): Promise<void> {
+  const manifest: ManifestEntry[] = [];
+
+  for (const downloadUrl of downloadUrls) {
+    const urlParts = downloadUrl.split("/");
+    const version = urlParts[urlParts.length - 2];
+    const artifactName = urlParts[urlParts.length - 1];
+    if (!artifactName.startsWith("uv-")) {
+      continue;
+    }
+    if (artifactName.startsWith("uv-installer")) {
+      continue;
+    }
+    const artifactParts = artifactName.split(".")[0].split("-");
+    manifest.push({
+      version: version,
+      artifactName: artifactName,
+      arch: artifactParts[1],
+      platform: artifactName.split(`uv-${artifactParts[1]}-`)[1].split(".")[0],
+      downloadUrl: downloadUrl,
+    });
+  }
+  core.debug(`Updating manifest-file: ${JSON.stringify(manifest)}`);
+  await fs.writeFile(manifestUrl, JSON.stringify(manifest));
+}

src/setup-uv.ts

@@ -1,9 +1,10 @@
 import * as core from "@actions/core";
 import * as path from "node:path";
 import {
-  downloadVersion,
   tryGetFromToolCache,
   resolveVersion,
+  downloadVersionFromGithub,
+  downloadVersionFromManifest,
 } from "./download/download-version";
 import { restoreCache } from "./cache/restore-cache";
 
@@ -14,23 +15,27 @@ import {
   type Platform,
 } from "./utils/platforms";
 import {
+  activateEnvironment as activateEnvironmentInput,
   cacheLocalPath,
   checkSum,
+  ignoreEmptyWorkdir,
   enableCache,
   githubToken,
-  pyProjectFile,
   pythonVersion,
   toolBinDir,
   toolDir,
-  uvFile,
   version as versionInput,
+  workingDirectory,
+  serverUrl,
+  manifestFile,
 } from "./utils/inputs";
 import * as exec from "@actions/exec";
 import fs from "node:fs";
-import { getUvVersionFromConfigFile } from "./utils/pyproject";
+import { getUvVersionFromConfigFile } from "./utils/config-file";
 
 async function run(): Promise<void> {
-  const platform = getPlatform();
+  detectEmptyWorkdir();
+  const platform = await getPlatform();
   const arch = getArch();
 
   try {
@@ -42,10 +47,11 @@ async function run(): Promise<void> {
     }
     const setupResult = await setupUv(platform, arch, checkSum, githubToken);
 
-    addUvToPath(setupResult.uvDir);
     addToolBinToPath();
+    addUvToPathAndOutput(setupResult.uvDir);
     setToolDir();
-    await setupPython();
+    setupPython();
+    await activateEnvironment();
     addMatchers();
     setCacheDir(cacheLocalPath);
 
@@ -61,13 +67,27 @@ async function run(): Promise<void> {
   }
 }
 
+function detectEmptyWorkdir(): void {
+  if (fs.readdirSync(".").length === 0) {
+    if (ignoreEmptyWorkdir) {
+      core.info(
+        "Empty workdir detected. Ignoring because ignore-empty-workdir is enabled",
+      );
+    } else {
+      core.warning(
+        "Empty workdir detected. This may cause unexpected behavior. You can enable ignore-empty-workdir to mute this warning.",
+      );
+    }
+  }
+}
+
 async function setupUv(
   platform: Platform,
   arch: Architecture,
   checkSum: string | undefined,
   githubToken: string,
 ): Promise<{ uvDir: string; version: string }> {
-  const resolvedVersion = await determineVersion();
+  const resolvedVersion = await determineVersion(manifestFile);
   const toolCacheResult = tryGetFromToolCache(arch, resolvedVersion);
   if (toolCacheResult.installedPath) {
     core.info(`Found uv in tool-cache for ${toolCacheResult.version}`);
@@ -77,13 +97,29 @@ async function setupUv(
     };
   }
 
-  const downloadVersionResult = await downloadVersion(
-    platform,
-    arch,
-    resolvedVersion,
-    checkSum,
-    githubToken,
-  );
+  let downloadVersionResult: { version: string; cachedToolDir: string };
+  if (serverUrl !== "https://github.com") {
+    core.warning(
+      "The input server-url is deprecated. Please use manifest-file instead.",
+    );
+    downloadVersionResult = await downloadVersionFromGithub(
+      serverUrl,
+      platform,
+      arch,
+      resolvedVersion,
+      checkSum,
+      githubToken,
+    );
+  } else {
+    downloadVersionResult = await downloadVersionFromManifest(
+      manifestFile,
+      platform,
+      arch,
+      resolvedVersion,
+      checkSum,
+      githubToken,
+    );
+  }
 
   return {
     uvDir: downloadVersionResult.cachedToolDir,
@@ -91,29 +127,33 @@ async function setupUv(
   };
 }
 
-async function determineVersion(): Promise<string> {
+async function determineVersion(
+  manifestFile: string | undefined,
+): Promise<string> {
   if (versionInput !== "") {
-    return await resolveVersion(versionInput, githubToken);
+    return await resolveVersion(versionInput, manifestFile, githubToken);
   }
-  const configFile = uvFile !== "" ? uvFile : pyProjectFile;
-  if (configFile !== "") {
-    const versionFromConfigFile = getUvVersionFromConfigFile(configFile);
-    if (versionFromConfigFile === undefined) {
-      core.warning(
-        `Could not find required-version under [tool.uv] in ${configFile}. Falling back to latest`,
-      );
-    }
-    return await resolveVersion(versionFromConfigFile || "latest", githubToken);
+  const versionFromUvToml = getUvVersionFromConfigFile(
+    `${workingDirectory}${path.sep}uv.toml`,
+  );
+  const versionFromPyproject = getUvVersionFromConfigFile(
+    `${workingDirectory}${path.sep}pyproject.toml`,
+  );
+  if (versionFromUvToml === undefined && versionFromPyproject === undefined) {
+    core.info(
+      "Could not determine uv version from uv.toml or pyproject.toml. Falling back to latest.",
+    );
   }
-  if (!fs.existsSync("uv.toml") && !fs.existsSync("pyproject.toml")) {
-    return await resolveVersion("latest", githubToken);
-  }
-  const versionFile = fs.existsSync("uv.toml") ? "uv.toml" : "pyproject.toml";
-  const versionFromConfigFile = getUvVersionFromConfigFile(versionFile);
-  return await resolveVersion(versionFromConfigFile || "latest", githubToken);
+  return await resolveVersion(
+    versionFromUvToml || versionFromPyproject || "latest",
+    manifestFile,
+    githubToken,
+  );
 }
 
-function addUvToPath(cachedPath: string): void {
+function addUvToPathAndOutput(cachedPath: string): void {
+  core.setOutput("uv-path", `${cachedPath}${path.sep}uv`);
+  core.setOutput("uvx-path", `${cachedPath}${path.sep}uvx`);
   core.addPath(cachedPath);
   core.info(`Added ${cachedPath} to the path`);
 }
@@ -145,24 +185,29 @@ function setToolDir(): void {
   }
 }
 
-async function setupPython(): Promise<void> {
+function setupPython(): void {
   if (pythonVersion !== "") {
     core.exportVariable("UV_PYTHON", pythonVersion);
     core.info(`Set UV_PYTHON to ${pythonVersion}`);
-    const options: exec.ExecOptions = {
-      silent: !core.isDebug(),
-    };
-    const execArgs = ["venv", "--python", pythonVersion];
+  }
+}
+
+async function activateEnvironment(): Promise<void> {
+  if (activateEnvironmentInput) {
+    const execArgs = ["venv", ".venv", "--directory", workingDirectory];
 
     core.info("Activating python venv...");
-    await exec.exec("uv", execArgs, options);
+    await exec.exec("uv", execArgs);
 
-    let venvBinPath = ".venv/bin";
+    let venvBinPath = `${workingDirectory}${path.sep}.venv${path.sep}bin`;
     if (process.platform === "win32") {
-      venvBinPath = ".venv/Scripts";
+      venvBinPath = `${workingDirectory}${path.sep}.venv${path.sep}Scripts`;
     }
     core.addPath(path.resolve(venvBinPath));
-    core.exportVariable("VIRTUAL_ENV", path.resolve(".venv"));
+    core.exportVariable(
+      "VIRTUAL_ENV",
+      path.resolve(`${workingDirectory}${path.sep}.venv`),
+    );
   }
 }
 

src/update-known-checksums.ts

@@ -1,38 +0,0 @@
-import * as semver from "semver";
-import * as core from "@actions/core";
-import { Octokit } from "@octokit/core";
-import { paginateRest } from "@octokit/plugin-paginate-rest";
-import { restEndpointMethods } from "@octokit/plugin-rest-endpoint-methods";
-
-import { OWNER, REPO } from "./utils/constants";
-
-import { updateChecksums } from "./download/checksum/update-known-checksums";
-
-const PaginatingOctokit = Octokit.plugin(paginateRest, restEndpointMethods);
-
-async function run(): Promise<void> {
-  const checksumFilePath = process.argv.slice(2)[0];
-  const github_token = process.argv.slice(2)[1];
-
-  const octokit = new PaginatingOctokit({
-    auth: github_token,
-  });
-
-  const response = await octokit.paginate(octokit.rest.repos.listReleases, {
-    owner: OWNER,
-    repo: REPO,
-  });
-  const downloadUrls: string[] = response.flatMap((release) =>
-    release.assets
-      .filter((asset) => asset.name.endsWith(".sha256"))
-      .map((asset) => asset.browser_download_url),
-  );
-  await updateChecksums(checksumFilePath, downloadUrls);
-
-  const latestVersion = response
-    .map((release) => release.tag_name)
-    .sort(semver.rcompare)[0];
-  core.setOutput("latest-version", latestVersion);
-}
-
-run();

src/update-known-versions.ts

@@ -0,0 +1,58 @@
+import * as semver from "semver";
+import * as core from "@actions/core";
+import { Octokit } from "./utils/octokit";
+
+import { OWNER, REPO } from "./utils/constants";
+
+import { updateChecksums } from "./download/checksum/update-known-checksums";
+import {
+  updateVersionManifest,
+  getLatestKnownVersion,
+} from "./download/version-manifest";
+
+async function run(): Promise<void> {
+  const checksumFilePath = process.argv.slice(2)[0];
+  const versionsManifestFile = process.argv.slice(2)[1];
+  const githubToken = process.argv.slice(2)[2];
+
+  const octokit = new Octokit({
+    auth: githubToken,
+  });
+
+  const { data: latestRelease } = await octokit.rest.repos.getLatestRelease({
+    owner: OWNER,
+    repo: REPO,
+  });
+
+  const latestKnownVersion = await getLatestKnownVersion(undefined);
+
+  if (semver.lte(latestRelease.tag_name, latestKnownVersion)) {
+    core.info(
+      `Latest release (${latestRelease.tag_name}) is not newer than the latest known version (${latestKnownVersion}). Skipping update.`,
+    );
+    return;
+  }
+
+  const releases = await octokit.paginate(octokit.rest.repos.listReleases, {
+    owner: OWNER,
+    repo: REPO,
+  });
+  const checksumDownloadUrls: string[] = releases.flatMap((release) =>
+    release.assets
+      .filter((asset) => asset.name.endsWith(".sha256"))
+      .map((asset) => asset.browser_download_url),
+  );
+  await updateChecksums(checksumFilePath, checksumDownloadUrls);
+
+  const artifactDownloadUrls: string[] = releases.flatMap((release) =>
+    release.assets
+      .filter((asset) => !asset.name.endsWith(".sha256"))
+      .map((asset) => asset.browser_download_url),
+  );
+
+  await updateVersionManifest(versionsManifestFile, artifactDownloadUrls);
+
+  core.setOutput("latest-version", latestRelease.tag_name);
+}
+
+run();

src/utils/config-file.ts

@@ -5,8 +5,9 @@ import * as toml from "smol-toml";
 export function getUvVersionFromConfigFile(
   filePath: string,
 ): string | undefined {
+  core.info(`Trying to find required-version for uv in: ${filePath}`);
   if (!fs.existsSync(filePath)) {
-    core.warning(`Could not find file: ${filePath}`);
+    core.info(`Could not find file: ${filePath}`);
     return undefined;
   }
   let requiredVersion: string | undefined;

src/utils/fetch.ts

@@ -0,0 +1,21 @@
+import { fetch as undiciFetch, ProxyAgent, type RequestInit } from "undici";
+
+export function getProxyAgent() {
+  const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+  if (httpProxy) {
+    return new ProxyAgent(httpProxy);
+  }
+
+  const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (httpsProxy) {
+    return new ProxyAgent(httpsProxy);
+  }
+
+  return undefined;
+}
+
+export const fetch = async (url: string, opts: RequestInit) =>
+  await undiciFetch(url, {
+    dispatcher: getProxyAgent(),
+    ...opts,
+  });

src/utils/inputs.ts

@@ -1,10 +1,11 @@
 import * as core from "@actions/core";
 import path from "node:path";
+import { getManifestFromRepo } from "@actions/tool-cache";
 
 export const version = core.getInput("version");
-export const pyProjectFile = core.getInput("pyproject-file");
-export const uvFile = core.getInput("uv-file");
 export const pythonVersion = core.getInput("python-version");
+export const activateEnvironment = core.getBooleanInput("activate-environment");
+export const workingDirectory = core.getInput("working-directory");
 export const checkSum = core.getInput("checksum");
 export const enableCache = getEnableCache();
 export const cacheSuffix = core.getInput("cache-suffix") || "";
@@ -13,9 +14,13 @@ export const cacheDependencyGlob = core.getInput("cache-dependency-glob");
 export const pruneCache = core.getInput("prune-cache") === "true";
 export const ignoreNothingToCache =
   core.getInput("ignore-nothing-to-cache") === "true";
+export const ignoreEmptyWorkdir =
+  core.getInput("ignore-empty-workdir") === "true";
 export const toolBinDir = getToolBinDir();
 export const toolDir = getToolDir();
+export const serverUrl = core.getInput("server-url");
 export const githubToken = core.getInput("github-token");
+export const manifestFile = getManifestFile();
 
 function getEnableCache(): boolean {
   const enableCacheInput = core.getInput("enable-cache");
@@ -62,12 +67,18 @@ function getCacheLocalPath(): string {
   if (cacheLocalPathInput !== "") {
     return expandTilde(cacheLocalPathInput);
   }
-  if (process.env.RUNNER_TEMP !== undefined) {
-    return `${process.env.RUNNER_TEMP}${path.sep}setup-uv-cache`;
+  if (process.env.RUNNER_ENVIRONMENT === "github-hosted") {
+    if (process.env.RUNNER_TEMP !== undefined) {
+      return `${process.env.RUNNER_TEMP}${path.sep}setup-uv-cache`;
+    }
+    throw Error(
+      "Could not determine UV_CACHE_DIR. Please make sure RUNNER_TEMP is set or provide the cache-local-path input",
+    );
   }
-  throw Error(
-    "Could not determine UV_CACHE_DIR. Please make sure RUNNER_TEMP is set or provide the cache-local-path input",
-  );
+  if (process.platform === "win32") {
+    return `${process.env.APPDATA}${path.sep}uv${path.sep}cache`;
+  }
+  return `${process.env.HOME}${path.sep}.cache${path.sep}uv`;
 }
 
 function expandTilde(input: string): string {
@@ -76,3 +87,11 @@ function expandTilde(input: string): string {
   }
   return input;
 }
+
+function getManifestFile(): string | undefined {
+  const manifestFileInput = core.getInput("manifest-file");
+  if (manifestFileInput !== "") {
+    return manifestFileInput;
+  }
+  return undefined;
+}

src/utils/octokit.ts

@@ -0,0 +1,38 @@
+import { Octokit as Core } from "@octokit/core";
+import type {
+  Constructor,
+  OctokitOptions,
+} from "@octokit/core/dist-types/types";
+import {
+  paginateRest,
+  type PaginateInterface,
+} from "@octokit/plugin-paginate-rest";
+import { legacyRestEndpointMethods } from "@octokit/plugin-rest-endpoint-methods";
+import { fetch as customFetch } from "./fetch";
+
+export type { RestEndpointMethodTypes } from "@octokit/plugin-rest-endpoint-methods";
+
+const DEFAULTS = {
+  baseUrl: "https://api.github.com",
+  userAgent: "setup-uv",
+};
+
+export const Octokit: typeof Core &
+  Constructor<
+    {
+      paginate: PaginateInterface;
+    } & ReturnType<typeof legacyRestEndpointMethods>
+  > = Core.plugin(paginateRest, legacyRestEndpointMethods).defaults(
+  function buildDefaults(options: OctokitOptions): OctokitOptions {
+    return {
+      ...DEFAULTS,
+      ...options,
+      request: {
+        fetch: customFetch,
+        ...options.request,
+      },
+    };
+  },
+);
+
+export type Octokit = InstanceType<typeof Octokit>;

src/utils/platforms.ts

@@ -1,10 +1,17 @@
+import * as exec from "@actions/exec";
+import * as core from "@actions/core";
 export type Platform =
   | "unknown-linux-gnu"
   | "unknown-linux-musl"
   | "unknown-linux-musleabihf"
   | "apple-darwin"
   | "pc-windows-msvc";
-export type Architecture = "i686" | "x86_64" | "aarch64";
+export type Architecture =
+  | "i686"
+  | "x86_64"
+  | "aarch64"
+  | "s390x"
+  | "powerpc64le";
 
 export function getArch(): Architecture | undefined {
   const arch = process.arch;
@@ -12,6 +19,8 @@ export function getArch(): Architecture | undefined {
     ia32: "i686",
     x64: "x86_64",
     arm64: "aarch64",
+    s390x: "s390x",
+    ppc64: "powerpc64le",
   };
 
   if (arch in archMapping) {
@@ -19,15 +28,49 @@ export function getArch(): Architecture | undefined {
   }
 }
 
-export function getPlatform(): Platform | undefined {
-  const platform = process.platform;
+export async function getPlatform(): Promise<Platform | undefined> {
+  const processPlatform = process.platform;
   const platformMapping: { [key: string]: Platform } = {
     linux: "unknown-linux-gnu",
     darwin: "apple-darwin",
     win32: "pc-windows-msvc",
   };
 
-  if (platform in platformMapping) {
-    return platformMapping[platform];
+  if (processPlatform in platformMapping) {
+    const platform = platformMapping[processPlatform];
+    if (platform === "unknown-linux-gnu") {
+      const isMusl = await isMuslOs();
+      return isMusl ? "unknown-linux-musl" : platform;
+    }
+    return platform;
+  }
+}
+
+async function isMuslOs(): Promise<boolean> {
+  let stdOutput = "";
+  let errOutput = "";
+  const options: exec.ExecOptions = {
+    silent: !core.isDebug(),
+    listeners: {
+      stdout: (data: Buffer) => {
+        stdOutput += data.toString();
+      },
+      stderr: (data: Buffer) => {
+        errOutput += data.toString();
+      },
+    },
+    ignoreReturnCode: true,
+  };
+
+  try {
+    const execArgs = ["--version"];
+    await exec.exec("ldd", execArgs, options);
+    return stdOutput.includes("musl") || errOutput.includes("musl");
+  } catch (error) {
+    const err = error as Error;
+    core.warning(
+      `Failed to determine glibc or musl. Falling back to glibc. Error: ${err.message}`,
+    );
+    return false;
   }
 }