Use uv from tool-cache to prune cache

chore: update known checksums for 0.5.29

Co-authored-by: eifinger <1481961+eifinger@users.noreply.github.com>

.eslintignore

@@ -1,4 +0,0 @@
-dist/
-lib/
-node_modules/
-jest.config.js

.eslintrc.json

@@ -1,61 +0,0 @@
-{
-  "plugins": ["jest", "@typescript-eslint"],
-  "extends": ["plugin:github/recommended"],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": 9,
-    "sourceType": "module",
-    "project": "./tsconfig.json"
-  },
-  "rules": {
-    "no-shadow": "off",
-    "@typescript-eslint/no-shadow": ["error"],
-    "i18n-text/no-en": "off",
-    "eslint-comments/no-use": "off",
-    "import/no-namespace": "off",
-    "no-unused-vars": "off",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/explicit-member-accessibility": [
-      "error",
-      { "accessibility": "no-public" }
-    ],
-    "@typescript-eslint/no-require-imports": "error",
-    "@typescript-eslint/array-type": "error",
-    "@typescript-eslint/await-thenable": "error",
-    "@typescript-eslint/ban-ts-comment": "error",
-    "camelcase": "off",
-    "@typescript-eslint/consistent-type-assertions": "error",
-    "@typescript-eslint/explicit-function-return-type": [
-      "error",
-      { "allowExpressions": true }
-    ],
-    "@typescript-eslint/func-call-spacing": ["error", "never"],
-    "@typescript-eslint/no-array-constructor": "error",
-    "@typescript-eslint/no-empty-interface": "error",
-    "@typescript-eslint/no-explicit-any": "error",
-    "@typescript-eslint/no-extraneous-class": "error",
-    "@typescript-eslint/no-for-in-array": "error",
-    "@typescript-eslint/no-inferrable-types": "error",
-    "@typescript-eslint/no-misused-new": "error",
-    "@typescript-eslint/no-namespace": "error",
-    "@typescript-eslint/no-non-null-assertion": "warn",
-    "@typescript-eslint/no-unnecessary-qualifier": "error",
-    "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-useless-constructor": "error",
-    "@typescript-eslint/no-var-requires": "error",
-    "@typescript-eslint/prefer-for-of": "warn",
-    "@typescript-eslint/prefer-function-type": "warn",
-    "@typescript-eslint/prefer-includes": "error",
-    "@typescript-eslint/prefer-string-starts-ends-with": "error",
-    "@typescript-eslint/promise-function-async": "error",
-    "@typescript-eslint/require-array-sort-compare": "error",
-    "@typescript-eslint/restrict-plus-operands": "error",
-    "@typescript-eslint/type-annotation-spacing": "error",
-    "@typescript-eslint/unbound-method": "error"
-  },
-  "env": {
-    "node": true,
-    "es6": true,
-    "jest/globals": true
-  }
-}

.github/workflows/release-drafter.yml

@@ -14,6 +14,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 🚀 Run Release Drafter
-        uses: release-drafter/release-drafter@v6.0.0
+        uses: release-drafter/release-drafter@v6.1.0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

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

@@ -11,10 +11,7 @@ concurrency:
 
 jobs:
   test-setup-cache:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest]
+    runs-on: windows-latest
     steps:
       - uses: actions/checkout@v4
       - name: Setup with cache
@@ -25,10 +22,7 @@ jobs:
       - run: uv sync
         working-directory: __tests__\fixtures\uv-project
   test-restore-cache:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest]
+    runs-on: windows-latest
     needs: test-setup-cache
     steps:
       - uses: actions/checkout@v4

.github/workflows/test-cache.yml

@@ -14,21 +14,65 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, macos-14]
+        enable-cache: [ "true", "false", "auto" ]
+        os: ["ubuntu-latest", "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 }}
+          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:
-        os: [ubuntu-latest, macos-latest, macos-14]
+        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
@@ -37,7 +81,7 @@ jobs:
         uses: ./
         with:
           enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-requirements-txt
       - name: Cache was hit
         run: |
           if [ "$CACHE_HIT" != "true" ]; then
@@ -45,8 +89,10 @@ jobs:
           fi
         env:
           CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
-      - run: uv sync
-        working-directory: __tests__/fixtures/uv-project
+      - 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
@@ -59,7 +105,7 @@ jobs:
           cache-dependency-glob: |
             __tests__/fixtures/uv-project/uv.lock
             **/pyproject.toml
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
+          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:
@@ -79,7 +125,8 @@ jobs:
           cache-dependency-glob: |
             __tests__/fixtures/uv-project/uv.lock
             **/pyproject.toml
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
+          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
@@ -89,19 +136,19 @@ jobs:
           CACHE_HIT: ${{ steps.restore.outputs.cache-hit }}
 
   test-setup-cache-local:
-    runs-on: oracle-aarch64
+    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 }}
+          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: oracle-aarch64
+    runs-on: selfhosted-ubuntu-arm64
     needs: test-setup-cache-local
     steps:
       - uses: actions/checkout@v4
@@ -110,7 +157,7 @@ jobs:
         uses: ./
         with:
           enable-cache: true
-          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}
+          cache-suffix: ${{ github.run_id }}-${{ github.run_attempt }}-test-setup-cache-local
           cache-local-path: /tmp/uv-cache
       - name: Cache was hit
         run: |
@@ -121,3 +168,62 @@ jobs:
           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.yml

@@ -21,23 +21,25 @@ jobs:
           npm install
       - run: |
           npm run all
+      - name: Make sure no changes from linters are detected
+        run: |
+          git diff --exit-code
   test-default-version:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, macos-14, oracle-aarch64]
+        os: [ubuntu-latest, macos-latest, macos-14]
     steps:
       - uses: actions/checkout@v4
-      - name: Install default version
+      - name: Install latest version
         uses: ./
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
   test-specific-version:
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, macos-14, oracle-aarch64]
-        uv-version: ["latest", "0.3.0", "0.3.2"]
+        uv-version: ["0.3.0", "0.3.2", "0.3", "0.3.x", ">=0.3.0"]
     steps:
       - uses: actions/checkout@v4
       - name: Install version ${{ matrix.uv-version }}
@@ -46,19 +48,68 @@ jobs:
           version: ${{ matrix.uv-version }}
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
+  test-semver-range:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install version 0.3
+        id: setup-uv
+        uses: ./
+        with:
+          version: "0.3"
+      - name: Correct version gets installed
+        run: |
+          if [ "$UV_VERSION" != "0.3.5" ]; then
+            exit 1
+          fi
+        env:
+          UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
+  test-pyproject-file-version:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install version 0.5.14
+        id: setup-uv
+        uses: ./
+        with:
+          pyproject-file: "__tests__/fixtures/pyproject-toml-project/pyproject.toml"
+      - name: Correct version gets installed
+        run: |
+          if [ "$UV_VERSION" != "0.5.14" ]; then
+            exit 1
+          fi
+        env:
+          UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
+  test-uv-file-version:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install version 0.5.15
+        id: setup-uv
+        uses: ./
+        with:
+          pyproject-file: "__tests__/fixtures/uv-toml-project/pyproject.toml"
+          uv-file: "__tests__/fixtures/uv-toml-project/uv.toml"
+      - name: Correct version gets installed
+        run: |
+          if [ "$UV_VERSION" != "0.5.15" ]; then
+            exit 1
+          fi
+        env:
+          UV_VERSION: ${{ steps.setup-uv.outputs.uv-version }}
   test-checksum:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, oracle-aarch64]
+        os: [ubuntu-latest, macos-latest]
         checksum:
           ["4d9279ad5ca596b1e2d703901d508430eb07564dc4d8837de9e2fca9c90f8ecd"]
         exclude:
-          - os: oracle-aarch64
+          - os: macos-latest
             checksum: "4d9279ad5ca596b1e2d703901d508430eb07564dc4d8837de9e2fca9c90f8ecd"
         include:
-          - os: oracle-aarch64
-            checksum: "e11b01402ab645392c7ad6044db63d37e4fd1e745e015306993b07695ea5f9f8"
+          - os: macos-latest
+            checksum: "a70cbfbf3bb5c08b2f84963b4f12c94e08fbb2468ba418a3bfe1066fbe9e7218"
     steps:
       - uses: actions/checkout@v4
       - name: Checksum matches expected
@@ -66,6 +117,8 @@ jobs:
         with:
           version: "0.3.2"
           checksum: ${{ matrix.checksum }}
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project
   test-with-explicit-token:
     runs-on: ubuntu-latest
     steps:
@@ -83,3 +136,79 @@ jobs:
       - name: Install default version
         uses: ./
       - run: uvx ruff --version
+  test-tool-install:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          [
+            ubuntu-latest,
+            macos-latest,
+            macos-14,
+            windows-latest,
+          ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install default version
+        uses: ./
+      - run: uv tool install ruff
+      - run: ruff --version
+  test-tilde-expansion-tool-dirs:
+    runs-on: selfhosted-ubuntu-arm64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup with cache
+        uses: ./
+        with:
+          tool-bin-dir: "~/tool-bin-dir"
+          tool-dir: "~/tool-dir"
+      - name: "Check if tool dirs are expanded"
+        run: |
+          if ! echo "$PATH" | grep -q "/home/ubuntu/tool-bin-dir"; then
+              echo "PATH does not contain /home/ubuntu/tool-bin-dir: $PATH"
+              exit 1
+          fi
+          if [ "$UV_TOOL_DIR" != "/home/ubuntu/tool-dir" ]; then
+              echo "UV_TOOL_DIR does not contain /home/ubuntu/tool-dir: $UV_TOOL_DIR"
+              exit 1
+          fi
+  test-python-version:
+    runs-on: ubuntu-latest
+    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
+      - name: Verify UV_PYTHON is set to correct version
+        run: |
+          echo "$UV_PYTHON"
+          if [ "$UV_PYTHON" != "3.13.1t" ]; then
+            exit 1
+          fi
+        shell: bash
+      - name: Verify packages can be installed
+        run: uv pip install --python=3.13.1t pip
+        shell: bash
+      - name: Verify python version is correct
+        run: |
+          python --version
+          if [ "$(python --version)" != "Python 3.13.1" ]; then
+            exit 1
+          fi
+        shell: bash
+
+  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:
+          pyproject-file: "__tests__/fixtures/malformed-pyproject-toml-project/pyproject.toml"
+      - run: uv sync
+        working-directory: __tests__/fixtures/uv-project

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

@@ -1,6 +1,8 @@
 name: "Update known checksums"
 on:
   workflow_dispatch:
+  schedule:
+    - cron: "0 4 * * *" # Run every day at 4am UTC
 
 jobs:
   build:
@@ -17,7 +19,7 @@ jobs:
           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@8867c4aba1b742c39f8d0ba35429c2dfa4b6cb20 # v7.0.1
+        uses: peter-evans/create-pull-request@67ccf781d68cd99b580ae25a5c18a1cc84ffff1f # v7.0.6
         with:
           commit-message: "chore: update known checksums"
           title:

.gitignore

@@ -96,4 +96,7 @@ Thumbs.db
 
 # Ignore built ts files
 __tests__/runner/*
-lib/**/*
+lib/**/*
+
+# Idea IDEs (PyCharm, WebStorm, IntelliJ, etc)
+.idea/

.prettierignore

@@ -1,3 +0,0 @@
-dist/
-lib/
-node_modules/

.prettierrc.json

@@ -1,4 +0,0 @@
-{
-  "trailingComma": "all",
-  "proseWrap": "always"
-}

README.md

@@ -11,54 +11,142 @@ Set up your GitHub Actions workflow with a specific version of [uv](https://docs
 ## Contents
 
 - [Usage](#usage)
-  - [Install specific version](#install-specific-version)
-  - [Install latest version](#install-latest-version)
+  - [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)
+  - [Python version](#python-version)
   - [Validate checksum](#validate-checksum)
   - [Enable Caching](#enable-caching)
-    - [Local cache path](#local-cache-path)
     - [Cache dependency glob](#cache-dependency-glob)
+  - [Local cache path](#local-cache-path)
+  - [Disable cache pruning](#disable-cache-pruning)
+  - [Ignore nothing to cache](#ignore-nothing-to-cache)
   - [GitHub authentication token](#github-authentication-token)
+  - [UV_TOOL_DIR](#uv_tool_dir)
+  - [UV_TOOL_BIN_DIR](#uv_tool_bin_dir)
+  - [Tilde Expansion](#tilde-expansion)
 - [How it works](#how-it-works)
 - [FAQ](#faq)
 
 ## Usage
 
-### Install the latest version (default)
+### Install a required-version or latest (default)
 
 ```yaml
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v2
-  with:
-    version: "latest"
+  uses: astral-sh/setup-uv@v5
 ```
 
+If you do not specify a version, this action will look for a [required-version](https://docs.astral.sh/uv/reference/settings/#required-version)
+in a `uv.toml` or `pyproject.toml` file in the repository root. If none is found, the latest version will be installed.
+
 For an example workflow, see
 [here](https://github.com/charliermarsh/autobot/blob/e42c66659bf97b90ca9ff305a19cc99952d0d43f/.github/workflows/ci.yaml).
 
-> [!TIP]
->
-> Using `latest` requires that uv download the executable on every run, which incurs a cost
-> (especially on self-hosted runners). As a best practice, consider pinning the version to a
-> specific release.
+### Install the latest version
+
+```yaml
+- name: Install the latest version of uv
+  uses: astral-sh/setup-uv@v5
+  with:
+    version: "latest"
+```
 
 ### Install a specific version
 
 ```yaml
 - name: Install a specific version of uv
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     version: "0.4.4"
 ```
 
+### Install a version by supplying a semver range
+
+You can specify a [semver range](https://github.com/npm/node-semver?tab=readme-ov-file#ranges)
+to install the latest version that satisfies the range.
+
+```yaml
+- name: Install a semver range of uv
+  uses: astral-sh/setup-uv@v5
+  with:
+    version: ">=0.4.0"
+```
+
+```yaml
+- name: Pinning a minor version of uv
+  uses: astral-sh/setup-uv@v5
+  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
+  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"
+```
+
+### 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
+
+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
+  with:
+    python-version: 3.13t
+- run: uv pip install --python=3.13t pip
+```
+
+You can combine this with a matrix to test multiple python versions:
+
+```yaml
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install the latest version of uv and set the python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Test with python ${{ matrix.python-version }}
+        run: uv run --frozen pytest
+```
+
 ### Validate checksum
 
-You can also specify a checksum to validate the downloaded file. Checksums up to the default version
-are automatically verified by this action. The sha265 hashes can be found on the
+You can specify a checksum to validate the downloaded executable. Checksums up to the default version
+are automatically verified by this action. The sha256 hashes can be found on the
 [releases page](https://github.com/astral-sh/uv/releases) of the uv repo.
 
 ```yaml
 - name: Install a specific version and validate the checksum
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     version: "0.3.1"
     checksum: "e11b01402ab645392c7ad6044db63d37e4fd1e745e015306993b07695ea5f9f8"
@@ -66,16 +154,20 @@ are automatically verified by this action. The sha265 hashes can be found on the
 
 ### Enable caching
 
-If you enable caching, the [uv cache](https://docs.astral.sh/uv/concepts/cache/) will be cached to
-the GitHub Actions Cache. This can speed up runs that reuse the cache by several minutes. The cache
-will always be reused on self-hosted runners.
+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.
+
+> [!TIP]
+>
+> On self-hosted runners this is usually not needed since the cache generated by uv on the runner's
+> filesystem is not removed after a run. For more details see [Local cache path](#local-cache-path).
 
 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@v2
+  uses: astral-sh/setup-uv@v5
   with:
     enable-cache: true
     cache-suffix: "optional-suffix"
@@ -90,54 +182,105 @@ use it in subsequent steps. For example, to use the cache in the above case:
   run: echo "Cache was restored"
 ```
 
-#### Local cache path
-
-If you want to save the cache to a local path other than the default path (`/tmp/setup-uv-cache`),
-specify the path with the `cache-local-path` input.
-
-```yaml
-- name: Define a custom uv cache path
-  uses: astral-sh/setup-uv@v2
-  with:
-    enable-cache: true
-    cache-local-path: "/path/to/cache"
-```
-
 #### Cache dependency glob
 
-If you want to control when the cache is invalidated, specify a glob pattern with the
-`cache-dependency-glob` input. The cache will be invalidated if any file matching the glob pattern
-changes. The glob matches files relative to the repository root.
+If you want to control when the GitHub Actions cache is invalidated, specify a glob pattern with the
+`cache-dependency-glob` input. The GitHub Actions cache will be invalidated if any file matching the glob pattern
+changes. If you use relative paths, they are relative to the repository root.
+
+> [!NOTE]
+>
+> The default is
+> ```yaml
+> cache-dependency-glob: |
+>   **/requirements*.txt
+>   **/uv.lock
+> ```
 
 ```yaml
 - name: Define a cache dependency glob
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     enable-cache: true
-    cache-dependency-glob: "uv.lock"
-```
-
-```yaml
-- name: Define a cache dependency glob
-  uses: astral-sh/setup-uv@v2
-  with:
-    enable-cache: true
-    cache-dependency-glob: "**requirements*.txt"
+    cache-dependency-glob: "**/pyproject.toml"
 ```
 
 ```yaml
 - name: Define a list of cache dependency globs
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     enable-cache: true
     cache-dependency-glob: |
-      '**requirements*.txt'
-      '**pyproject.toml'
+      **/requirements*.txt
+      **/pyproject.toml
+```
+
+```yaml
+- name: Define an absolute cache dependency glob
+  uses: astral-sh/setup-uv@v5
+  with:
+    enable-cache: true
+    cache-dependency-glob: "/tmp/my-folder/requirements*.txt"
+```
+
+```yaml
+- name: Never invalidate the cache
+  uses: astral-sh/setup-uv@v5
+  with:
+    enable-cache: true
+    cache-dependency-glob: ""
+```
+
+### Local cache path
+
+This action controls where uv stores its cache on the runner's filesystem by setting `UV_CACHE_DIR`.
+It defaults to `setup-uv-cache` in the `TMP` dir, `D:\a\_temp\uv-tool-dir` on Windows and
+`/tmp/setup-uv-cache` on Linux/macOS. You can change the default by specifying the path with the
+`cache-local-path` input.
+
+```yaml
+- name: Define a custom uv cache path
+  uses: astral-sh/setup-uv@v5
+  with:
+    cache-local-path: "/path/to/cache"
+```
+
+### Disable cache pruning
+
+By default, the uv cache is pruned after every run, removing pre-built wheels, but retaining any
+wheels that were built from source. On GitHub-hosted runners, it's typically faster to omit those
+pre-built wheels from the cache (and instead re-download them from the registry on each run).
+However, on self-hosted or local runners, preserving the cache may be more efficient. See
+the [documentation](https://docs.astral.sh/uv/concepts/cache/#caching-in-continuous-integration) for
+more information.
+
+If you want to persist the entire cache across runs, disable cache pruning with the `prune-cache`
+input.
+
+```yaml
+- name: Don't prune the cache before saving it
+  uses: astral-sh/setup-uv@v5
+  with:
+    enable-cache: true
+    prune-cache: false
+```
+
+### Ignore nothing to cache
+
+By default, the action will fail if caching is enabled but there is nothing to upload (the uv cache directory does not exist).
+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
+  with:
+    enable-cache: true
+    ignore-nothing-to-cache: true
 ```
 
 ### GitHub authentication token
 
-This action uses the GitHub API to fetch the `uv` release artifacts. To avoid hitting the GitHub API
+This action uses the GitHub API to fetch the uv release artifacts. To avoid hitting the GitHub API
 rate limit too quickly, an authentication token can be provided via the `github-token` input. By
 default, the `GITHUB_TOKEN` secret is used, which is automatically provided by GitHub Actions.
 
@@ -147,11 +290,67 @@ 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@v2
+  uses: astral-sh/setup-uv@v5
   with:
     github-token: ${{ secrets.CUSTOM_GITHUB_TOKEN }}
 ```
 
+### UV_TOOL_DIR
+
+On Windows `UV_TOOL_DIR` is set to `uv-tool-dir` in the `TMP` dir (e.g. `D:\a\_temp\uv-tool-dir`).
+On GitHub hosted runners this is on the much faster `D:` drive.
+
+On all other platforms the tool environments are placed in the
+[default location](https://docs.astral.sh/uv/concepts/tools/#tools-directory).
+
+If you want to change this behaviour (especially on self-hosted runners) you can use the `tool-dir`
+input:
+
+```yaml
+- name: Install the latest version of uv with a custom tool dir
+  uses: astral-sh/setup-uv@v5
+  with:
+    tool-dir: "/path/to/tool/dir"
+```
+
+### UV_TOOL_BIN_DIR
+
+On Windows `UV_TOOL_BIN_DIR` is set to `uv-tool-bin-dir` in the `TMP` dir (e.g.
+`D:\a\_temp\uv-tool-bin-dir`). On GitHub hosted runners this is on the much faster `D:` drive. This
+path is also automatically added to the PATH.
+
+On all other platforms the tool binaries get installed to the
+[default location](https://docs.astral.sh/uv/concepts/tools/#the-bin-directory).
+
+If you want to change this behaviour (especially on self-hosted runners) you can use the
+`tool-bin-dir` input:
+
+```yaml
+- name: Install the latest version of uv with a custom tool bin dir
+  uses: astral-sh/setup-uv@v5
+  with:
+    tool-bin-dir: "/path/to/tool-bin/dir"
+```
+
+### Tilde Expansion
+
+This action supports expanding the `~` character to the user's home directory for the following inputs:
+
+- `cache-local-path`
+- `tool-dir`
+- `tool-bin-dir`
+- `cache-dependency-glob`
+
+```yaml
+- name: Expand the tilde character
+  uses: astral-sh/setup-uv@v5
+  with:
+    cache-local-path: "~/path/to/cache"
+    tool-dir: "~/path/to/tool/dir"
+    tool-bin-dir: "~/path/to/tool-bin/dir"
+    cache-dependency-glob: "~/my-cache-buster"
+```
+
 ## How it works
 
 This action downloads uv from the uv repo's official
@@ -166,21 +365,22 @@ by name (`uv`).
 
 ### Do I still need `actions/setup-python` alongside `setup-uv`?
 
-No. This action is modelled as a drop-in replacement for `actions/setup-python` when using uv. With
-`setup-uv`, you can install a specific version of Python using `uv python install` rather than
+With `setup-uv`, you can install a specific version of Python using `uv python install` rather than
 relying on `actions/setup-python`.
 
+Using `actions/setup-python` can be faster, because GitHub caches the Python versions alongside the runner.
+
 For example:
 
 ```yaml
 - name: Checkout the repository
   uses: actions/checkout@main
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     enable-cache: true
 - name: Test
-  run: uv run --frozen pytest
+  run: uv run --frozen pytest  # Uses the Python version automatically installed by uv
 ```
 
 To install a specific version of Python, use
@@ -188,7 +388,7 @@ To install a specific version of Python, use
 
 ```yaml
 - name: Install the latest version of uv
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
   with:
     enable-cache: true
 - name: Install Python 3.12
@@ -207,7 +407,7 @@ output:
   uses: actions/checkout@main
 - name: Install the default version of uv
   id: setup-uv
-  uses: astral-sh/setup-uv@v2
+  uses: astral-sh/setup-uv@v5
 - name: Print the installed version
   run: echo "Installed uv version is ${{ steps.setup-uv.outputs.uv-version }}"
 ```

__tests__/fixtures/malformed-pyproject-toml-project/.python-version

@@ -0,0 +1 @@
+3.11

__tests__/fixtures/malformed-pyproject-toml-project/hello.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from malformed-pyproject-toml-project!")
+
+
+if __name__ == "__main__":
+    main()

__tests__/fixtures/malformed-pyproject-toml-project/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "malformed-pyproject-toml-project"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[malformed-toml

__tests__/fixtures/old-python-constraint-project/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "old-python-constraint-project"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.8,<=3.9"
+dependencies = [
+    "ruff>=0.6.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

__tests__/fixtures/old-python-constraint-project/src/old_python_constraint_project/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from uv-project!"

__tests__/fixtures/old-python-constraint-project/uv.lock

@@ -0,0 +1,38 @@
+version = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "ruff"
+version = "0.6.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/23/f4/279d044f66b79261fd37df76bf72b64471afab5d3b7906a01499c4451910/ruff-0.6.2.tar.gz", hash = "sha256:239ee6beb9e91feb8e0ec384204a763f36cb53fb895a1a364618c6abb076b3be", size = 2460281 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/4b/47dd7a69287afb4069fa42c198e899463605460a58120196711bfcf0446b/ruff-0.6.2-py3-none-linux_armv6l.whl", hash = "sha256:5c8cbc6252deb3ea840ad6a20b0f8583caab0c5ef4f9cca21adc5a92b8f79f3c", size = 9695871 },
+    { url = "https://files.pythonhosted.org/packages/ae/c3/8aac62ac4638c14a740ee76a755a925f2d0d04580ab790a9887accb729f6/ruff-0.6.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:17002fe241e76544448a8e1e6118abecbe8cd10cf68fde635dad480dba594570", size = 9459354 },
+    { url = "https://files.pythonhosted.org/packages/2f/cf/77fbd8d4617b9b9c503f9bffb8552c4e3ea1a58dc36975e7a9104ffb0f85/ruff-0.6.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:3dbeac76ed13456f8158b8f4fe087bf87882e645c8e8b606dd17b0b66c2c1158", size = 9163871 },
+    { url = "https://files.pythonhosted.org/packages/05/1c/765192bab32b79efbb498b06f0b9dcb3629112b53b8777ae1d19b8209e09/ruff-0.6.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:094600ee88cda325988d3f54e3588c46de5c18dae09d683ace278b11f9d4d534", size = 10096250 },
+    { url = "https://files.pythonhosted.org/packages/08/d0/86f3cb0f6934c99f759c232984a5204d67a26745cad2d9edff6248adf7d2/ruff-0.6.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:316d418fe258c036ba05fbf7dfc1f7d3d4096db63431546163b472285668132b", size = 9475376 },
+    { url = "https://files.pythonhosted.org/packages/cd/cc/4c8d0e225b559a3fae6092ec310d7150d3b02b4669e9223f783ef64d82c0/ruff-0.6.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d72b8b3abf8a2d51b7b9944a41307d2f442558ccb3859bbd87e6ae9be1694a5d", size = 10295634 },
+    { url = "https://files.pythonhosted.org/packages/db/96/d2699cfb1bb5a01c68122af43454c76c31331e1c8a9bd97d653d7c82524b/ruff-0.6.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:2aed7e243be68487aa8982e91c6e260982d00da3f38955873aecd5a9204b1d66", size = 11024941 },
+    { url = "https://files.pythonhosted.org/packages/8b/a9/6ecd66af8929e0f2a1ed308a4137f3521789f28f0eb97d32c2ca3aa7000c/ruff-0.6.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d371f7fc9cec83497fe7cf5eaf5b76e22a8efce463de5f775a1826197feb9df8", size = 10606894 },
+    { url = "https://files.pythonhosted.org/packages/e4/73/2ee4cd19f44992fedac1cc6db9e3d825966072f6dcbd4032f21cbd063170/ruff-0.6.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8f310d63af08f583363dfb844ba8f9417b558199c58a5999215082036d795a1", size = 11552886 },
+    { url = "https://files.pythonhosted.org/packages/60/4c/c0f1cd35ce4a93c54a6bb1ee6934a3a205fa02198dd076678193853ceea1/ruff-0.6.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7db6880c53c56addb8638fe444818183385ec85eeada1d48fc5abe045301b2f1", size = 10264945 },
+    { url = "https://files.pythonhosted.org/packages/c4/89/e45c9359b9cdd4245512ea2b9f2bb128a997feaa5f726fc9e8c7a66afadf/ruff-0.6.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:1175d39faadd9a50718f478d23bfc1d4da5743f1ab56af81a2b6caf0a2394f23", size = 10100007 },
+    { url = "https://files.pythonhosted.org/packages/06/74/0bd4e0a7ed5f6908df87892f9bf60a2356c0fd74102d8097298bd9b4f346/ruff-0.6.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:5b939f9c86d51635fe486585389f54582f0d65b8238e08c327c1534844b3bb9a", size = 9559267 },
+    { url = "https://files.pythonhosted.org/packages/54/03/3dc6dc9419f276f05805bf888c279e3e0b631284abd548d9e87cebb93aec/ruff-0.6.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d0d62ca91219f906caf9b187dea50d17353f15ec9bb15aae4a606cd697b49b4c", size = 9905304 },
+    { url = "https://files.pythonhosted.org/packages/5c/5b/d6a72a6a6bbf097c09de468326ef5fa1c9e7aa5e6e45979bc0d984b0dbe7/ruff-0.6.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7438a7288f9d67ed3c8ce4d059e67f7ed65e9fe3aa2ab6f5b4b3610e57e3cb56", size = 10341480 },
+    { url = "https://files.pythonhosted.org/packages/79/a9/0f2f21fe15ba537c46598f96aa9ae4a3d4b9ec64926664617ca6a8c772f4/ruff-0.6.2-py3-none-win32.whl", hash = "sha256:279d5f7d86696df5f9549b56b9b6a7f6c72961b619022b5b7999b15db392a4da", size = 7961901 },
+    { url = "https://files.pythonhosted.org/packages/b0/80/fff12ffe11853d9f4ea3e5221e6dd2e93640a161c05c9579833e09ad40a7/ruff-0.6.2-py3-none-win_amd64.whl", hash = "sha256:d9f3469c7dd43cd22eb1c3fc16926fb8258d50cb1b216658a07be95dd117b0f2", size = 8783320 },
+    { url = "https://files.pythonhosted.org/packages/56/91/577cdd64cce5e74d3f8b5ecb93f29566def569c741eb008aed4f331ef821/ruff-0.6.2-py3-none-win_arm64.whl", hash = "sha256:f28fcd2cd0e02bdf739297516d5643a945cc7caf09bd9bcb4d932540a5ea4fa9", size = 8225886 },
+]
+
+[[package]]
+name = "uv-project"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "ruff" }]

__tests__/fixtures/pyproject-toml-project/.python-version

@@ -0,0 +1 @@
+3.11

__tests__/fixtures/pyproject-toml-project/hello.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from pyproject-toml-project!")
+
+
+if __name__ == "__main__":
+    main()

__tests__/fixtures/pyproject-toml-project/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "pyproject-toml-project"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[dependency-groups]
+dev = [
+  "reuse==5.0.2",
+  {include-group = "lint"},
+]
+lint = [
+  "flake8==4.0.1",
+]
+
+[tool.uv]
+required-version = "==0.5.14"

__tests__/fixtures/requirements-txt-project/hello_world.py

@@ -0,0 +1 @@
+print("Hello world")

__tests__/fixtures/requirements-txt-project/requirements.txt

@@ -0,0 +1 @@
+ruff>=0.6.2

__tests__/fixtures/uv-toml-project/.python-version

@@ -0,0 +1 @@
+3.11

__tests__/fixtures/uv-toml-project/hello.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from uv-toml-project!")
+
+
+if __name__ == "__main__":
+    main()

__tests__/fixtures/uv-toml-project/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "uv-toml-project"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[tool.uv]
+required-version = "==0.5.14"

__tests__/fixtures/uv-toml-project/uv.toml

@@ -0,0 +1 @@
+required-version = "==0.5.15"

action.yml

@@ -1,33 +1,56 @@
-name: "Python setup uv"
-description: "Set up your GitHub Actions workflow with a specific version of uv"
-author: "eifinger"
+name: "astral-sh/setup-uv"
+description:
+  "Set up your GitHub Actions workflow with a specific version of uv."
+author: "astral-sh"
 inputs:
   version:
-    description: "The version of uv to install"
-    default: "latest"
+    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
   checksum:
     description: "The checksum of the uv version to install"
     required: false
   github-token:
     description:
-      "Used to increase the rate limit when retrieving versions and downloading
-      uv."
+      "Used to increase the rate limit when retrieving versions and downloading uv."
     required: false
     default: ${{ github.token }}
   enable-cache:
-    description: "Enable caching of the uv cache"
-    default: "false"
+    description: "Enable uploading of the uv cache"
+    default: "auto"
   cache-dependency-glob:
     description:
-      'Glob pattern to match files relative to the repository root to control
-      the cache. e.g. "uv.lock"'
-    required: false
+      "Glob pattern to match files relative to the repository root to control
+      the cache."
+    default: |
+      **/uv.lock
+      **/requirements*.txt
   cache-suffix:
     description: "Suffix for the cache key"
     required: false
   cache-local-path:
     description: "Local path to store the cache."
     default: ""
+  prune-cache:
+    description: "Prune cache before saving."
+    default: "true"
+  ignore-nothing-to-cache:
+    description: "Ignore when nothing is found to cache."
+    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
 outputs:
   uv-version:
     description: "The installed uv version. Useful when using latest."
@@ -40,4 +63,4 @@ runs:
   post-if: success()
 branding:
   icon: "package"
-  color: "blue"
+  color: "black"

biome.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.2/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": false
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": ["dist", "lib", "node_modules"]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space"
+  },
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "trailingCommas": "all"
+    }
+  }
+}

package.json

@@ -6,52 +6,42 @@
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc",
-    "format": "prettier --write .",
-    "format-check": "prettier --check .",
-    "lint": "eslint src/**/*.ts --fix",
+    "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",
     "test": "jest",
     "act": "act pull_request -W .github/workflows/test.yml --container-architecture linux/amd64 -s GITHUB_TOKEN=\"$(gh auth token)\"",
-    "update-known-checksums": "node dist/update-known-checksums/index.js src/download/checksum/known-checksums.ts \"$(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)\"",
     "all": "npm run build && npm run format && npm run lint && npm run package && npm test"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/astral-sh/setup-uv.git"
   },
-  "keywords": [
-    "actions",
-    "python",
-    "setup",
-    "uv"
-  ],
+  "keywords": ["actions", "python", "setup", "uv"],
   "author": "@eifinger",
   "license": "MIT",
   "dependencies": {
-    "@actions/cache": "^3.2.4",
-    "@actions/core": "^1.10.1",
+    "@actions/cache": "^4.0.0",
+    "@actions/core": "^1.11.1",
     "@actions/exec": "^1.1.1",
-    "@actions/github": "^6.0.0",
     "@actions/glob": "^0.5.0",
     "@actions/io": "^1.1.3",
-    "@actions/tool-cache": "^2.0.1",
-    "@octokit/rest": "^21.0.2"
+    "@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"
   },
   "devDependencies": {
-    "@types/node": "^22.5.4",
+    "@biomejs/biome": "1.9.4",
+    "@types/node": "^22.12.0",
     "@types/semver": "^7.5.8",
-    "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "@typescript-eslint/parser": "^7.18.0",
-    "@vercel/ncc": "^0.38.1",
-    "eslint": "^8.57.0",
-    "eslint-plugin-github": "^5.0.1",
-    "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-jest": "^28.8.3",
-    "eslint-plugin-prettier": "^5.2.1",
+    "@vercel/ncc": "^0.38.3",
     "jest": "^29.7.0",
     "js-yaml": "^4.1.0",
-    "prettier": "^3.3.3",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.5.4"
+    "typescript": "^5.7.3"
   }
 }

src/cache/restore-cache.ts

@@ -1,19 +1,21 @@
 import * as cache from "@actions/cache";
-import * as glob from "@actions/glob";
 import * as core from "@actions/core";
 import {
   cacheDependencyGlob,
   cacheLocalPath,
   cacheSuffix,
+  pythonVersion as pythonVersionInput,
 } from "../utils/inputs";
 import { getArch, getPlatform } from "../utils/platforms";
+import { hashFiles } from "../hash/hash-files";
+import * as exec from "@actions/exec";
 
 export const STATE_CACHE_KEY = "cache-key";
 export const STATE_CACHE_MATCHED_KEY = "cache-matched-key";
 const CACHE_VERSION = "1";
 
-export async function restoreCache(version: string): Promise<void> {
-  const cacheKey = await computeKeys(version);
+export async function restoreCache(): Promise<void> {
+  const cacheKey = await computeKeys();
 
   let matchedKey: string | undefined;
   core.info(
@@ -33,28 +35,56 @@ export async function restoreCache(version: string): Promise<void> {
   handleMatchResult(matchedKey, cacheKey);
 }
 
-async function computeKeys(version: string): Promise<string> {
+async function computeKeys(): Promise<string> {
   let cacheDependencyPathHash = "-";
   if (cacheDependencyGlob !== "") {
     core.info(
       `Searching files using cache dependency glob: ${cacheDependencyGlob.split("\n").join(",")}`,
     );
-    cacheDependencyPathHash += await glob.hashFiles(
-      cacheDependencyGlob,
-      undefined,
-      undefined,
-      true,
-    );
+    cacheDependencyPathHash += await hashFiles(cacheDependencyGlob, true);
     if (cacheDependencyPathHash === "-") {
-      throw new Error(
-        `No file in ${process.cwd()} matched to [${cacheDependencyGlob.split("\n").join(",")}], make sure you have checked out the target repository`,
+      core.warning(
+        `No file matched to [${cacheDependencyGlob.split("\n").join(",")}]. The cache will never get invalidated. Make sure you have checked out the target repository and configured the cache-dependency-glob input correctly.`,
       );
     }
-  } else {
-    cacheDependencyPathHash += "no-dependency-glob";
+  }
+  if (cacheDependencyPathHash === "-") {
+    cacheDependencyPathHash = "-no-dependency-glob";
   }
   const suffix = cacheSuffix ? `-${cacheSuffix}` : "";
-  return `setup-uv-${CACHE_VERSION}-${getArch()}-${getPlatform()}-${version}${cacheDependencyPathHash}${suffix}`;
+  const pythonVersion = await getPythonVersion();
+  return `setup-uv-${CACHE_VERSION}-${getArch()}-${getPlatform()}-${pythonVersion}${cacheDependencyPathHash}${suffix}`;
+}
+
+async function getPythonVersion(): Promise<string> {
+  if (pythonVersionInput !== "") {
+    return pythonVersionInput;
+  }
+
+  let output = "";
+  const options: exec.ExecOptions = {
+    silent: !core.isDebug(),
+    listeners: {
+      stdout: (data: Buffer) => {
+        output += data.toString();
+      },
+    },
+  };
+
+  try {
+    const execArgs = ["python", "find"];
+    await exec.exec("uv", execArgs, options);
+    const pythonPath = output.trim();
+
+    output = "";
+    await exec.exec(pythonPath, ["--version"], options);
+    // output is like "Python 3.8.10"
+    return output.split(" ")[1].trim();
+  } catch (error) {
+    const err = error as Error;
+    core.debug(`Failed to get python version from uv. Error: ${err.message}`);
+    return "unknown";
+  }
 }
 
 function handleMatchResult(

src/download/checksum/checksum.ts

@@ -1,9 +1,9 @@
-import * as fs from "fs";
-import * as crypto from "crypto";
+import * as fs from "node:fs";
+import * as crypto from "node:crypto";
 
 import * as core from "@actions/core";
 import { KNOWN_CHECKSUMS } from "./known-checksums";
-import { Architecture, Platform } from "../../utils/platforms";
+import type { Architecture, Platform } from "../../utils/platforms";
 
 export async function validateChecksum(
   checkSum: string | undefined,
@@ -12,11 +12,11 @@ export async function validateChecksum(
   platform: Platform,
   version: string,
 ): Promise<void> {
-  let isValid = true;
+  let isValid: boolean | undefined = undefined;
   if (checkSum !== undefined && checkSum !== "") {
     isValid = await validateFileCheckSum(downloadPath, checkSum);
   } else {
-    core.debug(`Checksum not provided. Checking known checksums.`);
+    core.debug("Checksum not provided. Checking known checksums.");
     const key = `${arch}-${platform}-${version}`;
     if (key in KNOWN_CHECKSUMS) {
       const knownChecksum = KNOWN_CHECKSUMS[`${arch}-${platform}-${version}`];
@@ -27,10 +27,12 @@ export async function validateChecksum(
     }
   }
 
-  if (!isValid) {
+  if (isValid === false) {
     throw new Error(`Checksum for ${downloadPath} did not match ${checkSum}.`);
   }
-  core.debug(`Checksum for ${downloadPath} is valid.`);
+  if (isValid === true) {
+    core.debug(`Checksum for ${downloadPath} is valid.`);
+  }
 }
 
 async function validateFileCheckSum(

src/download/checksum/update-known-checksums.ts

@@ -1,5 +1,6 @@
-import { promises as fs } from "fs";
+import { promises as fs } from "node:fs";
 import * as tc from "@actions/tool-cache";
+import { KNOWN_CHECKSUMS } from "./known-checksums";
 export async function updateChecksums(
   filePath: string,
   downloadUrls: string[],
@@ -7,31 +8,50 @@ export async function updateChecksums(
   await fs.rm(filePath);
   await fs.appendFile(
     filePath,
-    "// AUTOGENERATED_DO_NOT_EDIT\nexport const KNOWN_CHECKSUMS: {[key: string]: string} = {\n",
+    "// AUTOGENERATED_DO_NOT_EDIT\nexport const KNOWN_CHECKSUMS: { [key: string]: string } = {\n",
   );
   let firstLine = true;
   for (const downloadUrl of downloadUrls) {
-    const content = await downloadAssetContent(downloadUrl);
-    const checksum = content.split(" ")[0].trim();
     const key = getKey(downloadUrl);
+    if (key === undefined) {
+      continue;
+    }
+    const checksum = await getOrDownloadChecksum(key, downloadUrl);
     if (!firstLine) {
       await fs.appendFile(filePath, ",\n");
     }
-    await fs.appendFile(filePath, `  '${key}':\n    '${checksum}'`);
+    await fs.appendFile(filePath, `  "${key}":\n    "${checksum}"`);
     firstLine = false;
   }
-  await fs.appendFile(filePath, "}\n");
+  await fs.appendFile(filePath, ",\n};\n");
 }
 
-function getKey(downloadUrl: string): string {
+function getKey(downloadUrl: string): string | undefined {
   // https://github.com/astral-sh/uv/releases/download/0.3.2/uv-aarch64-apple-darwin.tar.gz.sha256
   const parts = downloadUrl.split("/");
   const fileName = parts[parts.length - 1];
+  if (fileName.startsWith("source")) {
+    return undefined;
+  }
   const name = fileName.split(".")[0].split("uv-")[1];
   const version = parts[parts.length - 2];
   return `${name}-${version}`;
 }
 
+async function getOrDownloadChecksum(
+  key: string,
+  downloadUrl: string,
+): Promise<string> {
+  let checksum = "";
+  if (key in KNOWN_CHECKSUMS) {
+    checksum = KNOWN_CHECKSUMS[key];
+  } else {
+    const content = await downloadAssetContent(downloadUrl);
+    checksum = content.split(" ")[0].trim();
+  }
+  return checksum;
+}
+
 async function downloadAssetContent(downloadUrl: string): Promise<string> {
   const downloadPath = await tc.downloadTool(downloadUrl);
   const content = await fs.readFile(downloadPath, "utf8");

src/download/download-latest.ts

@@ -1,71 +0,0 @@
-import * as core from "@actions/core";
-import * as tc from "@actions/tool-cache";
-import * as exec from "@actions/exec";
-import * as path from "path";
-import { Architecture, Platform } from "../utils/platforms";
-import { validateChecksum } from "./checksum/checksum";
-import { OWNER, REPO, TOOL_CACHE_NAME } from "../utils/constants";
-
-export async function downloadLatest(
-  platform: Platform,
-  arch: Architecture,
-  checkSum: string | undefined,
-  githubToken: string | undefined,
-): Promise<{ cachedToolDir: string; version: string }> {
-  const artifact = `uv-${arch}-${platform}`;
-  let downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/latest/download/${artifact}`;
-  if (platform === "pc-windows-msvc") {
-    downloadUrl += ".zip";
-  } else {
-    downloadUrl += ".tar.gz";
-  }
-  core.info(`Downloading uv from "${downloadUrl}" ...`);
-
-  const downloadPath = await tc.downloadTool(
-    downloadUrl,
-    undefined,
-    githubToken,
-  );
-  let uvExecutablePath: string;
-  let uvDir: string;
-  if (platform === "pc-windows-msvc") {
-    uvDir = await tc.extractZip(downloadPath);
-    // On windows extracting the zip does not create an intermediate directory
-    uvExecutablePath = path.join(uvDir, "uv.exe");
-  } else {
-    const extractedDir = await tc.extractTar(downloadPath);
-    uvDir = path.join(extractedDir, artifact);
-    uvExecutablePath = path.join(uvDir, "uv");
-  }
-  const version = await getVersion(uvExecutablePath);
-  await validateChecksum(checkSum, downloadPath, arch, platform, version);
-  const cachedToolDir = await tc.cacheDir(
-    uvDir,
-    TOOL_CACHE_NAME,
-    version,
-    arch,
-  );
-
-  return { cachedToolDir, version };
-}
-
-async function getVersion(uvExecutablePath: string): Promise<string> {
-  // Parse the output of `uv --version` to get the version
-  // The output looks like
-  // uv 0.3.1 (be17d132a 2024-08-21)
-
-  const options: exec.ExecOptions = {
-    silent: !core.isDebug(),
-  };
-  const execArgs = ["--version"];
-
-  let output = "";
-  options.listeners = {
-    stdout: (data: Buffer) => {
-      output += data.toString();
-    },
-  };
-  await exec.exec(uvExecutablePath, execArgs, options);
-  const parts = output.split(" ");
-  return parts[1];
-}

src/download/download-version.ts

@@ -1,18 +1,29 @@
 import * as core from "@actions/core";
 import * as tc from "@actions/tool-cache";
-import * as path from "path";
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
 import { OWNER, REPO, TOOL_CACHE_NAME } from "../utils/constants";
-import { Architecture, Platform } from "../utils/platforms";
+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);
 
 export function tryGetFromToolCache(
   arch: Architecture,
   version: string,
-): string | undefined {
+): { version: string; installedPath: string | undefined } {
   core.debug(`Trying to get uv from tool cache for ${version}...`);
   const cachedVersions = tc.findAllVersions(TOOL_CACHE_NAME, arch);
   core.debug(`Cached versions: ${cachedVersions}`);
-  return tc.find(TOOL_CACHE_NAME, version, arch);
+  let resolvedVersion = tc.evaluateVersions(cachedVersions, version);
+  if (resolvedVersion === "") {
+    resolvedVersion = version;
+  }
+  const installedPath = tc.find(TOOL_CACHE_NAME, resolvedVersion, arch);
+  return { version: resolvedVersion, installedPath };
 }
 
 export async function downloadVersion(
@@ -20,15 +31,15 @@ export async function downloadVersion(
   arch: Architecture,
   version: string,
   checkSum: string | undefined,
-  githubToken: string | undefined,
-): Promise<string> {
+  githubToken: string,
+): Promise<{ version: string; cachedToolDir: string }> {
+  const resolvedVersion = await resolveVersion(version, githubToken);
   const artifact = `uv-${arch}-${platform}`;
-  let downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/download/${version}/${artifact}`;
+  let extension = ".tar.gz";
   if (platform === "pc-windows-msvc") {
-    downloadUrl += ".zip";
-  } else {
-    downloadUrl += ".tar.gz";
+    extension = ".zip";
   }
+  const downloadUrl = `https://github.com/${OWNER}/${REPO}/releases/download/${resolvedVersion}/${artifact}${extension}`;
   core.info(`Downloading uv from "${downloadUrl}" ...`);
 
   const downloadPath = await tc.downloadTool(
@@ -36,16 +47,113 @@ export async function downloadVersion(
     undefined,
     githubToken,
   );
-  await validateChecksum(checkSum, downloadPath, arch, platform, version);
+  await validateChecksum(
+    checkSum,
+    downloadPath,
+    arch,
+    platform,
+    resolvedVersion,
+  );
 
   let uvDir: string;
   if (platform === "pc-windows-msvc") {
-    uvDir = await tc.extractZip(downloadPath);
+    const fullPathWithExtension = `${downloadPath}${extension}`;
+    await fs.copyFile(downloadPath, fullPathWithExtension);
+    uvDir = await tc.extractZip(fullPathWithExtension);
     // On windows extracting the zip does not create an intermediate directory
   } else {
     const extractedDir = await tc.extractTar(downloadPath);
     uvDir = path.join(extractedDir, artifact);
   }
-
-  return await tc.cacheDir(uvDir, TOOL_CACHE_NAME, version, arch);
+  const cachedToolDir = await tc.cacheDir(
+    uvDir,
+    TOOL_CACHE_NAME,
+    resolvedVersion,
+    arch,
+  );
+  return { version: resolvedVersion, cachedToolDir };
+}
+
+export async function resolveVersion(
+  versionInput: string,
+  githubToken: string,
+): Promise<string> {
+  const 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 === "") {
+    throw new Error(`No version found for ${version}`);
+  }
+  return resolvedVersion;
+}
+
+async function getAvailableVersions(githubToken: string): Promise<string[]> {
+  try {
+    const octokit = new PaginatingOctokit({
+      auth: githubToken,
+    });
+    return await getReleaseTagNames(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();
+      return await getReleaseTagNames(octokit);
+    }
+    throw err;
+  }
+}
+
+async function getReleaseTagNames(
+  octokit: InstanceType<typeof PaginatingOctokit>,
+): Promise<string[]> {
+  const response = await octokit.paginate(octokit.rest.repos.listReleases, {
+    owner: OWNER,
+    repo: REPO,
+  });
+  return response.map((release) => release.tag_name);
+}
+
+async function getLatestVersion(githubToken: string) {
+  const octokit = new PaginatingOctokit({
+    auth: githubToken,
+  });
+
+  let latestRelease: { tag_name: string } | undefined;
+  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;
+    }
+  }
+
+  if (!latestRelease) {
+    throw new Error("Could not determine latest release.");
+  }
+  return latestRelease.tag_name;
+}
+
+async function getLatestRelease(
+  octokit: InstanceType<typeof PaginatingOctokit>,
+) {
+  const { data: latestRelease } = await octokit.rest.repos.getLatestRelease({
+    owner: OWNER,
+    repo: REPO,
+  });
+  return latestRelease;
 }

src/hash/hash-files.ts

@@ -0,0 +1,48 @@
+import * as crypto from "node:crypto";
+import * as core from "@actions/core";
+import * as fs from "node:fs";
+import * as stream from "node:stream";
+import * as util from "node:util";
+import { create } from "@actions/glob";
+
+/**
+ * Hashes files matching the given glob pattern.
+ *
+ * Copied from https://github.com/actions/toolkit/blob/20ed2908f19538e9dfb66d8083f1171c0a50a87c/packages/glob/src/internal-hash-files.ts#L9-L49
+ * But supports hashing files outside the GITHUB_WORKSPACE.
+ * @param pattern The glob pattern to match files.
+ * @param verbose Whether to log the files being hashed.
+ */
+export async function hashFiles(
+  pattern: string,
+  verbose = false,
+): Promise<string> {
+  const globber = await create(pattern);
+  let hasMatch = false;
+  const writeDelegate = verbose ? core.info : core.debug;
+  const result = crypto.createHash("sha256");
+  let count = 0;
+  for await (const file of globber.globGenerator()) {
+    writeDelegate(file);
+    if (fs.statSync(file).isDirectory()) {
+      writeDelegate(`Skip directory '${file}'.`);
+      continue;
+    }
+    const hash = crypto.createHash("sha256");
+    const pipeline = util.promisify(stream.pipeline);
+    await pipeline(fs.createReadStream(file), hash);
+    result.write(hash.digest());
+    count++;
+    if (!hasMatch) {
+      hasMatch = true;
+    }
+  }
+  result.end();
+
+  if (hasMatch) {
+    writeDelegate(`Found ${count} files to hash.`);
+    return result.digest("hex");
+  }
+  writeDelegate("No matches found for glob");
+  return "";
+}

src/save-cache.ts

@@ -1,22 +1,34 @@
 import * as cache from "@actions/cache";
 import * as core from "@actions/core";
 import * as exec from "@actions/exec";
+import * as fs from "node:fs";
 import {
   STATE_CACHE_MATCHED_KEY,
   STATE_CACHE_KEY,
 } from "./cache/restore-cache";
-import { cacheLocalPath, enableCache } from "./utils/inputs";
+import {
+  cacheLocalPath,
+  enableCache,
+  ignoreNothingToCache,
+  pruneCache as shouldPruneCache,
+} from "./utils/inputs";
+import { STATE_CACHED_UV_DIR } from "./utils/constants";
 
 export async function run(): Promise<void> {
   try {
     if (enableCache) {
       await saveCache();
+      // node will stay alive if any promises are not resolved,
+      // which is a possibility if HTTP requests are dangling
+      // due to retries or timeouts. We know that if we got here
+      // that all promises that we care about have successfully
+      // resolved, so simply exit with success.
+      process.exit(0);
     }
   } catch (error) {
     const err = error as Error;
     core.setFailed(err.message);
   }
-  process.exit(0);
 }
 
 async function saveCache(): Promise<void> {
@@ -26,22 +38,45 @@ async function saveCache(): Promise<void> {
   if (!cacheKey) {
     core.warning("Error retrieving cache key from state.");
     return;
-  } else if (matchedKey === cacheKey) {
+  }
+  if (matchedKey === cacheKey) {
     core.info(`Cache hit occurred on key ${cacheKey}, not saving cache.`);
     return;
   }
 
-  await pruneCache();
+  if (shouldPruneCache) {
+    await pruneCache();
+  }
 
   core.info(`Saving cache path: ${cacheLocalPath}`);
-  await cache.saveCache([cacheLocalPath], cacheKey);
-
-  core.info(`cache saved with the key: ${cacheKey}`);
+  if (!fs.existsSync(cacheLocalPath) && !ignoreNothingToCache) {
+    throw new Error(
+      `Cache path ${cacheLocalPath} does not exist on disk. This likely indicates that there are no dependencies to cache. Consider disabling the cache input if it is not needed.`,
+    );
+  }
+  try {
+    await cache.saveCache([cacheLocalPath], cacheKey);
+    core.info(`cache saved with the key: ${cacheKey}`);
+  } catch (e) {
+    if (
+      e instanceof Error &&
+      e.message ===
+        "Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved."
+    ) {
+      core.info(
+        "No cacheable paths were found. Ignoring because ignore-nothing-to-save is enabled.",
+      );
+    } else {
+      throw e;
+    }
+  }
 }
 
 async function pruneCache(): Promise<void> {
+  const uvDir = core.getState(STATE_CACHED_UV_DIR);
   const options: exec.ExecOptions = {
-    silent: !core.isDebug(),
+    silent: false,
+    env: { PATH: uvDir },
   };
   const execArgs = ["cache", "prune", "--ci"];
 

src/setup-uv.ts

@@ -1,25 +1,34 @@
 import * as core from "@actions/core";
-import * as path from "path";
+import * as path from "node:path";
 import {
   downloadVersion,
   tryGetFromToolCache,
+  resolveVersion,
 } from "./download/download-version";
 import { restoreCache } from "./cache/restore-cache";
 
-import { downloadLatest } from "./download/download-latest";
 import {
-  Architecture,
+  type Architecture,
   getArch,
   getPlatform,
-  Platform,
+  type Platform,
 } from "./utils/platforms";
 import {
   cacheLocalPath,
   checkSum,
   enableCache,
   githubToken,
-  version,
+  pyProjectFile,
+  pythonVersion,
+  toolBinDir,
+  toolDir,
+  uvFile,
+  version as versionInput,
 } from "./utils/inputs";
+import * as exec from "@actions/exec";
+import fs from "node:fs";
+import { getUvVersionFromConfigFile } from "./utils/pyproject";
+import { STATE_CACHED_UV_DIR } from "./utils/constants";
 
 async function run(): Promise<void> {
   const platform = getPlatform();
@@ -32,61 +41,78 @@ async function run(): Promise<void> {
     if (arch === undefined) {
       throw new Error(`Unsupported architecture: ${process.arch}`);
     }
-    const setupResult = await setupUv(
-      platform,
-      arch,
-      version,
-      checkSum,
-      githubToken,
-    );
+    const setupResult = await setupUv(platform, arch, checkSum, githubToken);
 
+    core.saveState(STATE_CACHED_UV_DIR, setupResult.uvDir);
     addUvToPath(setupResult.uvDir);
-    core.setOutput("uv-version", version);
-    core.info(`Successfully installed uv version ${version}`);
-
+    addToolBinToPath();
+    setToolDir();
+    await setupPython();
     addMatchers();
     setCacheDir(cacheLocalPath);
 
+    core.setOutput("uv-version", setupResult.version);
+    core.info(`Successfully installed uv version ${setupResult.version}`);
+
     if (enableCache) {
-      await restoreCache(setupResult.version);
+      await restoreCache();
     }
+    process.exit(0);
   } catch (err) {
     core.setFailed((err as Error).message);
   }
-  process.exit(0);
 }
 
 async function setupUv(
   platform: Platform,
   arch: Architecture,
-  versionInput: string,
   checkSum: string | undefined,
-  githubToken: string | undefined,
+  githubToken: string,
 ): Promise<{ uvDir: string; version: string }> {
-  let installedPath: string | undefined;
-  let cachedToolDir: string;
-  let version: string;
-  if (versionInput === "latest") {
-    const result = await downloadLatest(platform, arch, checkSum, githubToken);
-    version = result.version;
-    cachedToolDir = result.cachedToolDir;
-  } else {
-    version = versionInput;
-    installedPath = tryGetFromToolCache(arch, versionInput);
-    if (installedPath) {
-      core.info(`Found uv in tool-cache for ${versionInput}`);
-      return { uvDir: installedPath, version };
-    }
-    cachedToolDir = await downloadVersion(
-      platform,
-      arch,
-      versionInput,
-      checkSum,
-      githubToken,
-    );
+  const resolvedVersion = await determineVersion();
+  const toolCacheResult = tryGetFromToolCache(arch, resolvedVersion);
+  if (toolCacheResult.installedPath) {
+    core.info(`Found uv in tool-cache for ${toolCacheResult.version}`);
+    return {
+      uvDir: toolCacheResult.installedPath,
+      version: toolCacheResult.version,
+    };
   }
 
-  return { uvDir: cachedToolDir, version };
+  const downloadVersionResult = await downloadVersion(
+    platform,
+    arch,
+    resolvedVersion,
+    checkSum,
+    githubToken,
+  );
+
+  return {
+    uvDir: downloadVersionResult.cachedToolDir,
+    version: downloadVersionResult.version,
+  };
+}
+
+async function determineVersion(): Promise<string> {
+  if (versionInput !== "") {
+    return await resolveVersion(versionInput, 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);
+  }
+  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);
 }
 
 function addUvToPath(cachedPath: string): void {
@@ -94,6 +120,54 @@ function addUvToPath(cachedPath: string): void {
   core.info(`Added ${cachedPath} to the path`);
 }
 
+function addToolBinToPath(): void {
+  if (toolBinDir !== undefined) {
+    core.exportVariable("UV_TOOL_BIN_DIR", toolBinDir);
+    core.info(`Set UV_TOOL_BIN_DIR to ${toolBinDir}`);
+    core.addPath(toolBinDir);
+    core.info(`Added ${toolBinDir} to the path`);
+  } else {
+    if (process.env.XDG_BIN_HOME !== undefined) {
+      core.addPath(process.env.XDG_BIN_HOME);
+      core.info(`Added ${process.env.XDG_BIN_HOME} to the path`);
+    } else if (process.env.XDG_DATA_HOME !== undefined) {
+      core.addPath(`${process.env.XDG_DATA_HOME}/../bin`);
+      core.info(`Added ${process.env.XDG_DATA_HOME}/../bin to the path`);
+    } else {
+      core.addPath(`${process.env.HOME}/.local/bin`);
+      core.info(`Added ${process.env.HOME}/.local/bin to the path`);
+    }
+  }
+}
+
+function setToolDir(): void {
+  if (toolDir !== undefined) {
+    core.exportVariable("UV_TOOL_DIR", toolDir);
+    core.info(`Set UV_TOOL_DIR to ${toolDir}`);
+  }
+}
+
+async function setupPython(): Promise<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];
+
+    core.info("Activating python venv...");
+    await exec.exec("uv", execArgs, options);
+
+    let venvBinPath = ".venv/bin";
+    if (process.platform === "win32") {
+      venvBinPath = ".venv/Scripts";
+    }
+    core.addPath(path.resolve(venvBinPath));
+    core.exportVariable("VIRTUAL_ENV", path.resolve(".venv"));
+  }
+}
+
 function setCacheDir(cacheLocalPath: string): void {
   core.exportVariable("UV_CACHE_DIR", cacheLocalPath);
   core.info(`Set UV_CACHE_DIR to ${cacheLocalPath}`);

src/update-known-checksums.ts

@@ -1,16 +1,22 @@
-import * as github from "@actions/github";
+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 * as semver from "semver";
 
 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 = github.getOctokit(github_token);
+  const octokit = new PaginatingOctokit({
+    auth: github_token,
+  });
 
   const response = await octokit.paginate(octokit.rest.repos.listReleases, {
     owner: OWNER,

src/utils/constants.ts

@@ -1,3 +1,4 @@
 export const REPO = "uv";
 export const OWNER = "astral-sh";
 export const TOOL_CACHE_NAME = "uv";
+export const STATE_CACHED_UV_DIR = "cached-uv-dir";

src/utils/inputs.ts

@@ -1,24 +1,78 @@
 import * as core from "@actions/core";
-import path from "path";
+import path from "node:path";
 
 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 checkSum = core.getInput("checksum");
-export const enableCache = core.getInput("enable-cache") === "true";
+export const enableCache = getEnableCache();
 export const cacheSuffix = core.getInput("cache-suffix") || "";
 export const cacheLocalPath = getCacheLocalPath();
-export const githubToken = core.getInput("github-token");
 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 toolBinDir = getToolBinDir();
+export const toolDir = getToolDir();
+export const githubToken = core.getInput("github-token");
+
+function getEnableCache(): boolean {
+  const enableCacheInput = core.getInput("enable-cache");
+  if (enableCacheInput === "auto") {
+    return process.env.RUNNER_ENVIRONMENT === "github-hosted";
+  }
+  return enableCacheInput === "true";
+}
+
+function getToolBinDir(): string | undefined {
+  const toolBinDirInput = core.getInput("tool-bin-dir");
+  if (toolBinDirInput !== "") {
+    return expandTilde(toolBinDirInput);
+  }
+  if (process.platform === "win32") {
+    if (process.env.RUNNER_TEMP !== undefined) {
+      return `${process.env.RUNNER_TEMP}${path.sep}uv-tool-bin-dir`;
+    }
+    throw Error(
+      "Could not determine UV_TOOL_BIN_DIR. Please make sure RUNNER_TEMP is set or provide the tool-bin-dir input",
+    );
+  }
+  return undefined;
+}
+
+function getToolDir(): string | undefined {
+  const toolDirInput = core.getInput("tool-dir");
+  if (toolDirInput !== "") {
+    return expandTilde(toolDirInput);
+  }
+  if (process.platform === "win32") {
+    if (process.env.RUNNER_TEMP !== undefined) {
+      return `${process.env.RUNNER_TEMP}${path.sep}uv-tool-dir`;
+    }
+    throw Error(
+      "Could not determine UV_TOOL_DIR. Please make sure RUNNER_TEMP is set or provide the tool-dir input",
+    );
+  }
+  return undefined;
+}
 
 function getCacheLocalPath(): string {
   const cacheLocalPathInput = core.getInput("cache-local-path");
   if (cacheLocalPathInput !== "") {
-    return cacheLocalPathInput;
+    return expandTilde(cacheLocalPathInput);
   }
   if (process.env.RUNNER_TEMP !== undefined) {
     return `${process.env.RUNNER_TEMP}${path.sep}setup-uv-cache`;
   }
-  if (process.platform === "win32") {
-    return "D:\\a\\_temp\\setup-uv-cache";
-  }
-  return "/tmp/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",
+  );
+}
+
+function expandTilde(input: string): string {
+  if (input.startsWith("~")) {
+    return `${process.env.HOME}${input.substring(1)}`;
+  }
+  return input;
 }

src/utils/pyproject.ts

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import * as core from "@actions/core";
+import * as toml from "smol-toml";
+
+export function getUvVersionFromConfigFile(
+  filePath: string,
+): string | undefined {
+  if (!fs.existsSync(filePath)) {
+    core.warning(`Could not find file: ${filePath}`);
+    return undefined;
+  }
+  let requiredVersion: string | undefined;
+  try {
+    requiredVersion = getRequiredVersion(filePath);
+  } catch (err) {
+    const message = (err as Error).message;
+    core.warning(`Error while parsing ${filePath}: ${message}`);
+    return undefined;
+  }
+
+  if (requiredVersion?.startsWith("==")) {
+    requiredVersion = requiredVersion.slice(2);
+  }
+  if (requiredVersion !== undefined) {
+    core.info(
+      `Found required-version for uv in ${filePath}: ${requiredVersion}`,
+    );
+  }
+  return requiredVersion;
+}
+
+function getRequiredVersion(filePath: string): string | undefined {
+  const fileContent = fs.readFileSync(filePath, "utf-8");
+
+  if (filePath.endsWith("pyproject.toml")) {
+    const tomlContent = toml.parse(fileContent) as {
+      tool?: { uv?: { "required-version"?: string } };
+    };
+    return tomlContent?.tool?.uv?.["required-version"];
+  }
+  const tomlContent = toml.parse(fileContent) as {
+    "required-version"?: string;
+  };
+  return tomlContent["required-version"];
+}

tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es6" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
+    "target": "ES2022" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
     "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
     "outDir": "./lib" /* Redirect output structure to the directory. */,
     "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,