Linting

GITHUB_ACTIONS_RUNNER_TRACE still takes precedence for back compat.

.devcontainer/devcontainer.json

@@ -4,13 +4,10 @@
   "features": {
     "ghcr.io/devcontainers/features/docker-in-docker:1": {},
     "ghcr.io/devcontainers/features/dotnet": {
-      "version": "8.0.412"
+      "version": "6.0.415"
     },
     "ghcr.io/devcontainers/features/node:1": {
-      "version": "20"
-    },
-    "ghcr.io/devcontainers/features/sshd:1": {
-      "version": "latest"
+      "version": "16"
     }
   },
   "customizations": {

.github/ISSUE_TEMPLATE/config.yml

@@ -7,7 +7,7 @@ contact_links:
     url: https://github.community/c/code-to-cloud/52
     about: If you have questions about GitHub Actions or need support writing workflows, please ask in the GitHub Community Support forum.
   - name: ✅ Feedback and suggestions for GitHub Actions
-    url: https://github.com/github/feedback/discussions/categories/actions
+    url: https://github.com/github/feedback/discussions/categories/actions-and-packages-feedback
     about: If you have feedback or suggestions about GitHub Actions, please open a discussion (or add to an existing one) in the GitHub Actions Feedback.  GitHub Actions Product Managers and Engineers monitor the feedback forum.
   - name: ‼️ GitHub Security Bug Bounty
     url: https://bounty.github.com/

.github/copilot-instructions.md

@@ -1,25 +0,0 @@
-## Making changes
-
-### Tests
-
-Whenever possible, changes should be accompanied by non-trivial tests that meaningfully exercise the core functionality of the new code being introduced.
-
-All tests are in the `Test/` directory at the repo root. Fast unit tests are in the `Test/L0` directory and by convention have the suffix `L0.cs`. For example: unit tests for a hypothetical `src/Runner.Worker/Foo.cs` would go in `src/Test/L0/Worker/FooL0.cs`.
-
-Run tests using this command:
-
-```sh
-cd src && ./dev.sh test
-```
-
-### Formatting
-
-After editing .cs files, always format the code using this command:
-
-```sh
-cd src && ./dev.sh format
-```
-
-### Feature Flags
-
-Wherever possible, all changes should be safeguarded by a feature flag; `Features` are declared in [Constants.cs](src/Runner.Common/Constants.cs).

.github/dependabot.yml

@@ -5,11 +5,6 @@ updates:
   schedule:
     interval: "daily" 
   target-branch: "main" 
-- package-ecosystem: "github-actions"
-  directory: "/"
-  schedule:
-    interval: "daily" 
-  target-branch: "main" 
 - package-ecosystem: "nuget"
   directory: "/src"
   schedule:

.github/workflows/build.yml

@@ -41,7 +41,7 @@ jobs:
           devScript: ./dev.sh
 
         - runtime: win-x64
-          os: windows-latest
+          os: windows-2019
           devScript: ./dev
 
         - runtime: win-arm64
@@ -50,7 +50,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v3
 
     # Build runner layout
     - name: Build & Layout Release
@@ -58,6 +58,29 @@ jobs:
         ${{ matrix.devScript }} layout Release ${{ matrix.runtime }}
       working-directory: src
 
+    # Check runtime/externals hash
+    - name: Compute/Compare runtime and externals Hash
+      shell: bash
+      run: |
+        echo "Current dotnet runtime hash result: $DOTNET_RUNTIME_HASH"
+        echo "Current Externals hash result: $EXTERNALS_HASH"
+
+        NeedUpdate=0
+        if [ "$EXTERNALS_HASH" != "$(cat ./src/Misc/contentHash/externals/${{ matrix.runtime }})" ] ;then
+          echo Hash mismatch, Update ./src/Misc/contentHash/externals/${{ matrix.runtime }} to $EXTERNALS_HASH
+          NeedUpdate=1
+        fi
+
+        if [ "$DOTNET_RUNTIME_HASH" != "$(cat ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }})" ] ;then
+          echo Hash mismatch, Update ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }} to $DOTNET_RUNTIME_HASH
+          NeedUpdate=1
+        fi
+
+        exit $NeedUpdate
+      env:
+        DOTNET_RUNTIME_HASH: ${{hashFiles('**/_layout_trims/runtime/**/*')}}
+        EXTERNALS_HASH: ${{hashFiles('**/_layout_trims/externals/**/*')}}
+
     # Run tests
     - name: L0
       run: |
@@ -69,14 +92,17 @@ jobs:
     - name: Package Release
       if: github.event_name != 'pull_request'
       run: |
-        ${{ matrix.devScript }} package Release ${{ matrix.runtime }}
+        ${{ matrix.devScript }} package Release
       working-directory: src
 
     # Upload runner package tar.gz/zip as artifact
     - name: Publish Artifact
       if: github.event_name != 'pull_request'
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
         name: runner-package-${{ matrix.runtime }}
         path: |
           _package
+          _package_trims/trim_externals
+          _package_trims/trim_runtime
+          _package_trims/trim_runtime_externals

.github/workflows/close-bugs-bot.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v8
         with:
           close-issue-message: "This issue does not seem to be a problem with the runner application, it concerns the GitHub actions platform more generally. Could you please post your feedback on the [GitHub Community Support Forum](https://github.com/orgs/community/discussions/categories/actions) which is actively monitored. Using the forum ensures that we route your problem to the correct team. 😃"
           exempt-issue-labels: "keep"
@@ -15,3 +15,4 @@ jobs:
           only-labels: "actions-bug"
           days-before-stale: 0
           days-before-close: 1
+          close-issue-reason: "completed"

.github/workflows/close-features-bot.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v8
         with:
           close-issue-message: "Thank you for your interest in the runner application and taking the time to provide your valuable feedback. We kindly ask you to redirect this feedback to the [GitHub Community Support Forum](https://github.com/orgs/community/discussions/categories/actions-and-packages) which our team actively monitors and would be a better place to start a discussion for new feature requests in GitHub Actions. For more information on this policy please [read our contribution guidelines](https://github.com/actions/runner#contribute). 😃"
           exempt-issue-labels: "keep"
@@ -15,3 +15,4 @@ jobs:
           only-labels: "actions-feature"
           days-before-stale: 0
           days-before-close: 1
+          close-issue-reason: "completed"

.github/workflows/codeql.yml

@@ -23,11 +23,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v3
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v2
       # Override language selection by uncommenting this and choosing your languages
       # with:
       #   languages: go, javascript, csharp, python, cpp, java
@@ -38,4 +38,4 @@ jobs:
       working-directory: src
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v2

.github/workflows/docker-buildx-upgrade.yml

@@ -1,144 +0,0 @@
-name: "Docker/Buildx Version Upgrade"
-
-on:
-  schedule:
-    - cron: '0 0 * * 1'  # Run every Monday at midnight
-  workflow_dispatch:      # Allow manual triggering
-
-jobs:
-  check-versions:
-    runs-on: ubuntu-latest
-    outputs:
-      DOCKER_SHOULD_UPDATE: ${{ steps.check_docker_version.outputs.SHOULD_UPDATE }}
-      DOCKER_LATEST_VERSION: ${{ steps.check_docker_version.outputs.LATEST_VERSION }}
-      DOCKER_CURRENT_VERSION: ${{ steps.check_docker_version.outputs.CURRENT_VERSION }}
-      BUILDX_SHOULD_UPDATE: ${{ steps.check_buildx_version.outputs.SHOULD_UPDATE }}
-      BUILDX_LATEST_VERSION: ${{ steps.check_buildx_version.outputs.LATEST_VERSION }}
-      BUILDX_CURRENT_VERSION: ${{ steps.check_buildx_version.outputs.CURRENT_VERSION }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-
-      - name: Check Docker version
-        id: check_docker_version
-        shell: bash
-        run: |
-          # Extract current Docker version from Dockerfile
-          current_version=$(grep "ARG DOCKER_VERSION=" ./images/Dockerfile | cut -d'=' -f2)
-
-          # Fetch latest Docker Engine version from Docker's download site
-          # This gets the latest Linux static binary version which matches what's used in the Dockerfile
-          latest_version=$(curl -s https://download.docker.com/linux/static/stable/x86_64/ | grep -o 'docker-[0-9]*\.[0-9]*\.[0-9]*\.tgz' | sort -V | tail -n 1 | sed 's/docker-\(.*\)\.tgz/\1/')
-
-          # Extra check to ensure we got a valid version
-          if [[ ! $latest_version =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            echo "Failed to retrieve a valid Docker version"
-            exit 1
-          fi
-          
-          should_update=0
-          [ "$current_version" != "$latest_version" ] && should_update=1
-
-          echo "CURRENT_VERSION=${current_version}" >> $GITHUB_OUTPUT
-          echo "LATEST_VERSION=${latest_version}" >> $GITHUB_OUTPUT
-          echo "SHOULD_UPDATE=${should_update}" >> $GITHUB_OUTPUT
-
-      - name: Check Buildx version
-        id: check_buildx_version
-        shell: bash
-        run: |
-          # Extract current Buildx version from Dockerfile
-          current_version=$(grep "ARG BUILDX_VERSION=" ./images/Dockerfile | cut -d'=' -f2)
-
-          # Fetch latest Buildx version
-          latest_version=$(curl -s https://api.github.com/repos/docker/buildx/releases/latest | jq -r '.tag_name' | sed 's/^v//')
-
-          should_update=0
-          [ "$current_version" != "$latest_version" ] && should_update=1
-
-          echo "CURRENT_VERSION=${current_version}" >> $GITHUB_OUTPUT
-          echo "LATEST_VERSION=${latest_version}" >> $GITHUB_OUTPUT
-          echo "SHOULD_UPDATE=${should_update}" >> $GITHUB_OUTPUT
-
-      - name: Create annotations for versions
-        run: |
-          docker_should_update="${{ steps.check_docker_version.outputs.SHOULD_UPDATE }}"
-          buildx_should_update="${{ steps.check_buildx_version.outputs.SHOULD_UPDATE }}"
-          
-          # Show annotation if only Docker needs update
-          if [[ "$docker_should_update" == "1" && "$buildx_should_update" == "0" ]]; then
-            echo "::warning ::Docker version (${{ steps.check_docker_version.outputs.LATEST_VERSION }}) needs update but Buildx is current. Only updating when both need updates."
-          fi
-          
-          # Show annotation if only Buildx needs update
-          if [[ "$docker_should_update" == "0" && "$buildx_should_update" == "1" ]]; then
-            echo "::warning ::Buildx version (${{ steps.check_buildx_version.outputs.LATEST_VERSION }}) needs update but Docker is current. Only updating when both need updates."
-          fi
-          
-          # Show annotation when both are current
-          if [[ "$docker_should_update" == "0" && "$buildx_should_update" == "0" ]]; then
-            echo "::warning ::Latest Docker version is ${{ steps.check_docker_version.outputs.LATEST_VERSION }} and Buildx version is ${{ steps.check_buildx_version.outputs.LATEST_VERSION }}. No updates needed."
-          fi
-
-  update-versions:
-    permissions:
-      pull-requests: write
-      contents: write
-    needs: [check-versions]
-    if: ${{ needs.check-versions.outputs.DOCKER_SHOULD_UPDATE == 1 && needs.check-versions.outputs.BUILDX_SHOULD_UPDATE == 1 }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v5
-      
-      - name: Update Docker version
-        shell: bash
-        run: |
-          latest_version="${{ needs.check-versions.outputs.DOCKER_LATEST_VERSION }}"
-          current_version="${{ needs.check-versions.outputs.DOCKER_CURRENT_VERSION }}"
-          
-          # Update version in Dockerfile
-          sed -i "s/ARG DOCKER_VERSION=$current_version/ARG DOCKER_VERSION=$latest_version/g" ./images/Dockerfile
-      
-      - name: Update Buildx version
-        shell: bash
-        run: |
-          latest_version="${{ needs.check-versions.outputs.BUILDX_LATEST_VERSION }}"
-          current_version="${{ needs.check-versions.outputs.BUILDX_CURRENT_VERSION }}"
-          
-          # Update version in Dockerfile
-          sed -i "s/ARG BUILDX_VERSION=$current_version/ARG BUILDX_VERSION=$latest_version/g" ./images/Dockerfile
-      
-      - name: Commit changes and create Pull Request
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          # Setup branch and commit information
-          branch_name="feature/docker-buildx-upgrade"
-          commit_message="Upgrade Docker to v${{ needs.check-versions.outputs.DOCKER_LATEST_VERSION }} and Buildx to v${{ needs.check-versions.outputs.BUILDX_LATEST_VERSION }}"
-          pr_title="Update Docker to v${{ needs.check-versions.outputs.DOCKER_LATEST_VERSION }} and Buildx to v${{ needs.check-versions.outputs.BUILDX_LATEST_VERSION }}"
-          
-          # Configure git
-          git config --global user.name "github-actions[bot]"
-          git config --global user.email "<41898282+github-actions[bot]@users.noreply.github.com>"
-
-          # Create branch or switch to it if it exists
-          if git show-ref --quiet refs/remotes/origin/$branch_name; then
-            git fetch origin
-            git checkout -B "$branch_name" origin/$branch_name
-          else
-            git checkout -b "$branch_name"
-          fi
-          
-          # Commit and push changes
-          git commit -a -m "$commit_message"
-          git push --force origin "$branch_name"
-          
-          # Create PR
-          pr_body="Upgrades Docker version from ${{ needs.check-versions.outputs.DOCKER_CURRENT_VERSION }} to ${{ needs.check-versions.outputs.DOCKER_LATEST_VERSION }} and Docker Buildx version from ${{ needs.check-versions.outputs.BUILDX_CURRENT_VERSION }} to ${{ needs.check-versions.outputs.BUILDX_LATEST_VERSION }}.\n\n"
-          pr_body+="Release notes: https://docs.docker.com/engine/release-notes/\n\n"
-          pr_body+="---\n\nAutogenerated by [Docker/Buildx Version Upgrade Workflow](https://github.com/actions/runner/blob/main/.github/workflows/docker-buildx-upgrade.yml)"
-          
-          gh pr create -B main -H "$branch_name" \
-            --title "$pr_title" \
-            --body "$pr_body"

.github/workflows/dotnet-upgrade.yml

@@ -15,7 +15,7 @@ jobs:
       DOTNET_CURRENT_MAJOR_MINOR_VERSION: ${{ steps.fetch_current_version.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v3
       - name: Get current major minor version
         id: fetch_current_version
         shell: bash
@@ -51,7 +51,7 @@ jobs:
         run: echo "::error links::feature/dotnet-sdk-upgrade${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }} https://github.com/actions/runner/tree/feature/dotnet-sdk-upgrade${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}::Branch feature/dotnetsdk-upgrade/${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }} already exists. Please take a look and delete that branch if you wish to recreate"
       - name: Create a warning annotation if no need to update
         if: ${{ steps.fetch_latest_version.outputs.SHOULD_UPDATE == 0 && steps.fetch_latest_version.outputs.BRANCH_EXISTS == 0 }}
-        run: echo "::warning ::Latest DotNet SDK patch is ${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}, and we are on ${{ steps.fetch_current_version.outputs.DOTNET_CURRENT_MAJOR_MINOR_PATCH_VERSION }}. No need to update"
+        run: echo "::warning ::Latest DotNet SDK patch is ${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}, and we are on ${{ steps.fetch_latest_version.outputs.DOTNET_CURRENT_MAJOR_MINOR_PATCH_VERSION }}. No need to update"
       - name: Update patch version
         if: ${{ steps.fetch_latest_version.outputs.SHOULD_UPDATE == 1 && steps.fetch_latest_version.outputs.BRANCH_EXISTS == 0 }}
         shell: bash
@@ -84,20 +84,221 @@ jobs:
           git commit -a -m "Upgrade dotnet sdk to v${{ steps.fetch_latest_version.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}"
           git push --set-upstream origin $branch_name
 
-  create-pr:
-    needs: [dotnet-update]
+  build-hashes:
     if: ${{ needs.dotnet-update.outputs.SHOULD_UPDATE == 1 && needs.dotnet-update.outputs.BRANCH_EXISTS == 0 }}
-    runs-on: ubuntu-latest
+    needs: [dotnet-update]
+    outputs: 
+      # pass outputs from this job to create-pr for use
+      DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION: ${{ needs.dotnet-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+      DOTNET_CURRENT_MAJOR_MINOR_VERSION: ${{ needs.dotnet-update.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}
+      NEEDS_HASH_UPDATE: ${{ steps.compute-hash.outputs.NEED_UPDATE }}
+    strategy:
+      fail-fast: false
+      matrix:
+        runtime: [ linux-x64, linux-arm64, linux-arm, win-x64, win-arm64, osx-x64, osx-arm64 ]
+        include:
+        - runtime: linux-x64
+          os: ubuntu-latest
+          devScript: ./dev.sh
+
+        - runtime: linux-arm64
+          os: ubuntu-latest
+          devScript: ./dev.sh
+
+        - runtime: linux-arm
+          os: ubuntu-latest
+          devScript: ./dev.sh
+
+        - runtime: osx-x64
+          os: macOS-latest
+          devScript: ./dev.sh
+
+        - runtime: osx-arm64
+          os: macOS-latest
+          devScript: ./dev.sh
+
+        - runtime: win-x64
+          os: windows-2019
+          devScript: ./dev
+
+        - runtime: win-arm64
+          os: windows-latest
+          devScript: ./dev
+
+    runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v3 
       with:
         ref: feature/dotnetsdk-upgrade/${{ needs.dotnet-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+
+    # Build runner layout
+    - name: Build & Layout Release
+      run: |
+        ${{ matrix.devScript }} layout Release ${{ matrix.runtime }}
+      working-directory: src
+
+    # Check runtime/externals hash
+    - name: Compute/Compare runtime and externals Hash
+      id: compute-hash
+      continue-on-error: true
+      shell: bash
+      run: |
+        echo "Current dotnet runtime hash result: $DOTNET_RUNTIME_HASH"
+        echo "Current Externals hash result: $EXTERNALS_HASH"
+
+        NeedUpdate=0
+        if [ "$EXTERNALS_HASH" != "$(cat ./src/Misc/contentHash/externals/${{ matrix.runtime }})" ] ;then
+          echo Hash mismatch, Update ./src/Misc/contentHash/externals/${{ matrix.runtime }} to $EXTERNALS_HASH
+
+          echo "EXTERNAL_HASH=$EXTERNALS_HASH" >> $GITHUB_OUTPUT
+          NeedUpdate=1
+        fi
+
+        if [ "$DOTNET_RUNTIME_HASH" != "$(cat ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }})" ] ;then
+          echo Hash mismatch, Update ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }} to $DOTNET_RUNTIME_HASH
+
+          echo "DOTNET_RUNTIME_HASH=$DOTNET_RUNTIME_HASH" >> $GITHUB_OUTPUT
+          NeedUpdate=1
+        fi
+
+        echo "NEED_UPDATE=$NeedUpdate" >> $GITHUB_OUTPUT
+      env:
+        DOTNET_RUNTIME_HASH: ${{hashFiles('**/_layout_trims/runtime/**/*')}}
+        EXTERNALS_HASH: ${{hashFiles('**/_layout_trims/externals/**/*')}}
+    - name: update hash
+      if: ${{ steps.compute-hash.outputs.NEED_UPDATE == 1 }}
+      shell: bash
+      run: |
+        ExternalHash=${{ steps.compute-hash.outputs.EXTERNAL_HASH }}
+        DotNetRuntimeHash=${{ steps.compute-hash.outputs.DOTNET_RUNTIME_HASH }}
+
+        if [ -n "$ExternalHash" ]; then
+          echo "$ExternalHash" > ./src/Misc/contentHash/externals/${{ matrix.runtime }}
+        fi
+
+        if [ -n "$DotNetRuntimeHash" ]; then
+          echo "$DotNetRuntimeHash" > ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }}
+        fi
+    - name: cache updated hashes
+      if: ${{ steps.compute-hash.outputs.NEED_UPDATE == 1 }}
+      uses: actions/cache/save@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/${{ matrix.runtime }}
+          ./src/Misc/contentHash/dotnetRuntime/${{ matrix.runtime }}
+        key: compute-hashes-${{ matrix.runtime }}-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+
+
+  hash-update:
+    needs: [build-hashes]
+    if: ${{ needs.build-hashes.outputs.NEEDS_HASH_UPDATE == 1 }}
+    outputs: 
+      # pass outputs from this job to create-pr for use
+      DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION: ${{ needs.build-hashes.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+      DOTNET_CURRENT_MAJOR_MINOR_VERSION: ${{ needs.build-hashes.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with: 
+        ref: feature/dotnetsdk-upgrade/${{ needs.build-hashes.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+    - name: Restore cached hashes - linux-x64
+      id: cache-restore-linux-x64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/linux-x64
+          ./src/Misc/contentHash/dotnetRuntime/linux-x64
+        key: compute-hashes-linux-x64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - linux-arm64
+      id: cache-restore-linux-arm64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/linux-arm64
+          ./src/Misc/contentHash/dotnetRuntime/linux-arm64
+        key: compute-hashes-linux-arm64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - linux-arm
+      id: cache-restore-linux-arm
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/linux-arm
+          ./src/Misc/contentHash/dotnetRuntime/linux-arm
+        key: compute-hashes-linux-arm-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - osx-x64
+      id: cache-restore-osx-x64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/osx-x64
+          ./src/Misc/contentHash/dotnetRuntime/osx-x64
+        key: compute-hashes-osx-x64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - osx-arm64
+      id: cache-restore-osx-arm64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/osx-arm64
+          ./src/Misc/contentHash/dotnetRuntime/osx-arm64
+        key: compute-hashes-osx-arm64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - win-x64
+      id: cache-restore-win-x64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/win-x64
+          ./src/Misc/contentHash/dotnetRuntime/win-x64
+        key: compute-hashes-win-x64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Restore cached hashes - win-arm64
+      id: cache-restore-win-arm64
+      uses: actions/cache/restore@v3
+      with:
+        enableCrossOsArchive: true
+        path: |
+          ./src/Misc/contentHash/externals/win-arm64
+          ./src/Misc/contentHash/dotnetRuntime/win-arm64
+        key: compute-hashes-win-arm64-${{ github.run_id }}-${{ github.run_number }}-${{ github.run_attempt }}
+    - name: Fetch cached computed hashes
+      if: steps.cache-restore-linux-x64.outputs.cache-hit == 'true' ||
+          steps.cache-restore-linux-arm64.outputs.cache-hit == 'true' ||
+          steps.cache-restore-linux-arm.outputs.cache-hit == 'true' ||
+          steps.cache-restore-win-x64.outputs.cache-hit == 'true' ||
+          steps.cache-restore-win-arm64.outputs.cache-hit == 'true' ||
+          steps.cache-restore-osx-x64.outputs.cache-hit == 'true' ||
+          steps.cache-restore-osx-arm64.outputs.cache-hit == 'true'
+      shell: bash
+      run: |
+        Environments=( "linux-x64" "linux-arm64" "linux-arm" "win-x64" "win-arm64" "osx-x64" "osx-arm64" )
+
+        git config --global user.name "github-actions[bot]"
+        git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+        git commit -a -m "Update computed hashes"
+        git push --set-upstream origin feature/dotnetsdk-upgrade/${{ needs.build-hashes.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+
+  create-pr:
+    needs: [hash-update]
+    outputs:
+      # pass outputs from this job to run-tests for use
+      DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION: ${{ needs.hash-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
+      DOTNET_CURRENT_MAJOR_MINOR_VERSION: ${{ needs.hash-update.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        ref: feature/dotnetsdk-upgrade/${{ needs.hash-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}
     - name: Create Pull Request
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       run: |
-        gh pr create -B main -H feature/dotnetsdk-upgrade/${{ needs.dotnet-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }} --title "Update dotnet sdk to latest version @${{ needs.dotnet-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}" --body "
-          https://dotnetcli.blob.core.windows.net/dotnet/Sdk/${{ needs.dotnet-update.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}/latest.version
+        gh pr create -B main -H feature/dotnetsdk-upgrade/${{ needs.hash-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }} --title "Update dotnet sdk to latest version @${{ needs.hash-update.outputs.DOTNET_LATEST_MAJOR_MINOR_PATCH_VERSION }}" --body "
+          https://dotnetcli.blob.core.windows.net/dotnet/Sdk/${{ needs.hash-update.outputs.DOTNET_CURRENT_MAJOR_MINOR_VERSION }}/latest.version
           
             
           ---

.github/workflows/lint.yml

@@ -0,0 +1,24 @@
+name: Lint
+
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          # Ensure full list of changed files within `super-linter`
+          fetch-depth: 0
+      - name: Run linters
+        uses: github/super-linter@v4
+        env:
+          DEFAULT_BRANCH: ${{ github.base_ref }}
+          EDITORCONFIG_FILE_NAME: .editorconfig
+          LINTER_RULES_PATH: /src/
+          VALIDATE_ALL_CODEBASE: false
+          VALIDATE_CSHARP: true

.github/workflows/publish-image.yml

@@ -0,0 +1,68 @@
+name: Publish Runner Image
+
+on:
+  workflow_dispatch:
+    inputs:
+      runnerVersion:
+        type: string
+        description: Version of the runner being installed
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository_owner }}/actions-runner
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Compute image version
+        id: image
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const fs = require('fs');
+            const inputRunnerVersion = "${{ github.event.inputs.runnerVersion }}"
+            if (inputRunnerVersion) {
+              console.log(`Using input runner version ${inputRunnerVersion}`)
+              core.setOutput('version', inputRunnerVersion);
+              return
+            }
+            const runnerVersion = fs.readFileSync('${{ github.workspace }}/src/runnerversion', 'utf8').replace(/\n$/g, '')
+            console.log(`Using runner version ${runnerVersion}`)
+            core.setOutput('version', runnerVersion);
+
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Log into registry ${{ env.REGISTRY }}
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        id: build-and-push
+        uses: docker/build-push-action@v3
+        with:
+          context: ./images
+          platforms: |
+            linux/amd64
+            linux/arm64
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.image.outputs.version }}
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+          build-args: |
+            RUNNER_VERSION=${{ steps.image.outputs.version }}
+          push: true
+          labels: |
+            org.opencontainers.image.source=${{github.server_url}}/${{github.repository}}
+            org.opencontainers.image.description=https://github.com/actions/runner/releases/tag/v${{ steps.image.outputs.version }}
+            org.opencontainers.image.licenses=MIT

.github/workflows/release.yml

@@ -11,15 +11,16 @@ jobs:
     if: startsWith(github.ref, 'refs/heads/releases/') || github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v3
 
     # Make sure ./releaseVersion match ./src/runnerversion
     # Query GitHub release ensure version is not used
     - name: Check version
-      uses: actions/github-script@v7.0.1
+      uses: actions/github-script@0.3.0
       with:
         github-token: ${{secrets.GITHUB_TOKEN}}
         script: |
+          const core = require('@actions/core')
           const fs = require('fs');
           const runnerVersion = fs.readFileSync('${{ github.workspace }}/src/runnerversion', 'utf8').replace(/\n$/g, '')
           const releaseVersion = fs.readFileSync('${{ github.workspace }}/releaseVersion', 'utf8').replace(/\n$/g, '')
@@ -29,7 +30,7 @@ jobs:
             return
           }
           try {
-            const release = await github.rest.repos.getReleaseByTag({
+            const release = await github.repos.getReleaseByTag({
               owner: '${{ github.event.repository.owner.name }}',
               repo: '${{ github.event.repository.name }}',
               tag: 'v' + runnerVersion
@@ -52,6 +53,27 @@ jobs:
       win-arm64-sha: ${{ steps.sha.outputs.win-arm64-sha256 }}
       osx-x64-sha: ${{ steps.sha.outputs.osx-x64-sha256 }}
       osx-arm64-sha: ${{ steps.sha.outputs.osx-arm64-sha256 }}
+      linux-x64-sha-noexternals: ${{ steps.sha_noexternals.outputs.linux-x64-sha256 }}
+      linux-arm64-sha-noexternals: ${{ steps.sha_noexternals.outputs.linux-arm64-sha256 }}
+      linux-arm-sha-noexternals: ${{ steps.sha_noexternals.outputs.linux-arm-sha256 }}
+      win-x64-sha-noexternals: ${{ steps.sha_noexternals.outputs.win-x64-sha256 }}
+      win-arm64-sha-noexternals: ${{ steps.sha_noexternals.outputs.win-arm64-sha256 }}
+      osx-x64-sha-noexternals: ${{ steps.sha_noexternals.outputs.osx-x64-sha256 }}
+      osx-arm64-sha-noexternals: ${{ steps.sha_noexternals.outputs.osx-arm64-sha256 }}
+      linux-x64-sha-noruntime: ${{ steps.sha_noruntime.outputs.linux-x64-sha256 }}
+      linux-arm64-sha-noruntime: ${{ steps.sha_noruntime.outputs.linux-arm64-sha256 }}
+      linux-arm-sha-noruntime: ${{ steps.sha_noruntime.outputs.linux-arm-sha256 }}
+      win-x64-sha-noruntime: ${{ steps.sha_noruntime.outputs.win-x64-sha256 }}
+      win-arm64-sha-noruntime: ${{ steps.sha_noruntime.outputs.win-arm64-sha256 }}
+      osx-x64-sha-noruntime: ${{ steps.sha_noruntime.outputs.osx-x64-sha256 }}
+      osx-arm64-sha-noruntime: ${{ steps.sha_noruntime.outputs.osx-arm64-sha256 }}
+      linux-x64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.linux-x64-sha256 }}
+      linux-arm64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.linux-arm64-sha256 }}
+      linux-arm-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.linux-arm-sha256 }}
+      win-x64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.win-x64-sha256 }}
+      win-arm64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.win-arm64-sha256 }}
+      osx-x64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.osx-x64-sha256 }}
+      osx-arm64-sha-noruntime-noexternals: ${{ steps.sha_noruntime_noexternals.outputs.osx-arm64-sha256 }}
     strategy:
       matrix:
         runtime: [ linux-x64, linux-arm64, linux-arm, win-x64, osx-x64, osx-arm64, win-arm64 ]
@@ -77,7 +99,7 @@ jobs:
           devScript: ./dev.sh
 
         - runtime: win-x64
-          os: windows-latest
+          os: windows-2019
           devScript: ./dev
 
         - runtime: win-arm64
@@ -86,7 +108,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v3
 
     # Build runner layout
     - name: Build & Layout Release
@@ -114,67 +136,113 @@ jobs:
       id: sha
       name: Compute SHA256
       working-directory: _package
+    - run: |
+        file=$(ls)
+        sha=$(sha256sum $file | awk '{ print $1 }')
+        echo "Computed sha256: $sha for $file"
+        echo "${{matrix.runtime}}-sha256=$sha" >> $GITHUB_OUTPUT
+        echo "sha256=$sha" >> $GITHUB_OUTPUT
+      shell: bash
+      id: sha_noexternals
+      name: Compute SHA256
+      working-directory: _package_trims/trim_externals
+    - run: |
+        file=$(ls)
+        sha=$(sha256sum $file | awk '{ print $1 }')
+        echo "Computed sha256: $sha for $file"
+        echo "${{matrix.runtime}}-sha256=$sha" >> $GITHUB_OUTPUT
+        echo "sha256=$sha" >> $GITHUB_OUTPUT
+      shell: bash
+      id: sha_noruntime
+      name: Compute SHA256
+      working-directory: _package_trims/trim_runtime
+    - run: |
+        file=$(ls)
+        sha=$(sha256sum $file | awk '{ print $1 }')
+        echo "Computed sha256: $sha for $file"
+        echo "${{matrix.runtime}}-sha256=$sha" >> $GITHUB_OUTPUT
+        echo "sha256=$sha" >> $GITHUB_OUTPUT
+      shell: bash
+      id: sha_noruntime_noexternals
+      name: Compute SHA256
+      working-directory: _package_trims/trim_runtime_externals
+
+    - name: Create trimmedpackages.json for ${{ matrix.runtime }}
+      if: matrix.runtime == 'win-x64' || matrix.runtime == 'win-arm64'
+      uses: actions/github-script@0.3.0
+      with:
+        github-token: ${{secrets.GITHUB_TOKEN}}
+        script: |
+          const core = require('@actions/core')
+          const fs = require('fs');
+          const runnerVersion = fs.readFileSync('src/runnerversion', 'utf8').replace(/\n$/g, '')
+          var trimmedPackages = fs.readFileSync('src/Misc/trimmedpackages_zip.json', 'utf8').replace(/<RUNNER_VERSION>/g, runnerVersion).replace(/<RUNNER_PLATFORM>/g, '${{ matrix.runtime }}')
+          trimmedPackages = trimmedPackages.replace(/<RUNTIME_HASH>/g, '${{hashFiles('**/_layout_trims/runtime/**/*')}}')
+          trimmedPackages = trimmedPackages.replace(/<EXTERNALS_HASH>/g, '${{hashFiles('**/_layout_trims/externals/**/*')}}')
+
+          trimmedPackages = trimmedPackages.replace(/<NO_RUNTIME_EXTERNALS_HASH>/g, '${{steps.sha_noruntime_noexternals.outputs.sha256}}')
+          trimmedPackages = trimmedPackages.replace(/<NO_RUNTIME_HASH>/g, '${{steps.sha_noruntime.outputs.sha256}}')
+          trimmedPackages = trimmedPackages.replace(/<NO_EXTERNALS_HASH>/g, '${{steps.sha_noexternals.outputs.sha256}}')
+
+          console.log(trimmedPackages)
+          fs.writeFileSync('${{ matrix.runtime }}-trimmedpackages.json', trimmedPackages)
+
+    - name: Create trimmedpackages.json for ${{ matrix.runtime }}
+      if: matrix.runtime != 'win-x64' && matrix.runtime != 'win-arm64'
+      uses: actions/github-script@0.3.0
+      with:
+        github-token: ${{secrets.GITHUB_TOKEN}}
+        script: |
+          const core = require('@actions/core')
+          const fs = require('fs');
+          const runnerVersion = fs.readFileSync('src/runnerversion', 'utf8').replace(/\n$/g, '')
+          var trimmedPackages = fs.readFileSync('src/Misc/trimmedpackages_targz.json', 'utf8').replace(/<RUNNER_VERSION>/g, runnerVersion).replace(/<RUNNER_PLATFORM>/g, '${{ matrix.runtime }}')
+          trimmedPackages = trimmedPackages.replace(/<RUNTIME_HASH>/g, '${{hashFiles('**/_layout_trims/runtime/**/*')}}')
+          trimmedPackages = trimmedPackages.replace(/<EXTERNALS_HASH>/g, '${{hashFiles('**/_layout_trims/externals/**/*')}}')
+
+          trimmedPackages = trimmedPackages.replace(/<NO_RUNTIME_EXTERNALS_HASH>/g, '${{steps.sha_noruntime_noexternals.outputs.sha256}}')
+          trimmedPackages = trimmedPackages.replace(/<NO_RUNTIME_HASH>/g, '${{steps.sha_noruntime.outputs.sha256}}')
+          trimmedPackages = trimmedPackages.replace(/<NO_EXTERNALS_HASH>/g, '${{steps.sha_noexternals.outputs.sha256}}')
+
+          console.log(trimmedPackages)
+          fs.writeFileSync('${{ matrix.runtime }}-trimmedpackages.json', trimmedPackages)
 
     # Upload runner package tar.gz/zip as artifact.
+    # Since each package name is unique, so we don't need to put ${{matrix}} info into artifact name
     - name: Publish Artifact
       if: github.event_name != 'pull_request'
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v2
       with:
-        name: runner-packages-${{ matrix.runtime }}
+        name: runner-packages
         path: |
           _package
+          _package_trims/trim_externals
+          _package_trims/trim_runtime
+          _package_trims/trim_runtime_externals
+          ${{ matrix.runtime }}-trimmedpackages.json
 
   release:
     needs: build
     runs-on: ubuntu-latest
     steps:
 
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v3
 
     # Download runner package tar.gz/zip produced by 'build' job
-    - name: Download Artifact (win-x64)
-      uses: actions/download-artifact@v5
+    - name: Download Artifact
+      uses: actions/download-artifact@v1
       with:
-        name: runner-packages-win-x64
-        path: ./
-    - name: Download Artifact (win-arm64)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-win-arm64
-        path: ./
-    - name: Download Artifact (osx-x64)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-osx-x64
-        path: ./
-    - name: Download Artifact (osx-arm64)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-osx-arm64
-        path: ./
-    - name: Download Artifact (linux-x64)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-linux-x64
-        path: ./
-    - name: Download Artifact (linux-arm)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-linux-arm
-        path: ./
-    - name: Download Artifact (linux-arm64)
-      uses: actions/download-artifact@v5
-      with:
-        name: runner-packages-linux-arm64
+        name: runner-packages
         path: ./
 
     # Create ReleaseNote file
     - name: Create ReleaseNote
       id: releaseNote
-      uses: actions/github-script@v7.0.1
+      uses: actions/github-script@0.3.0
       with:
         github-token: ${{secrets.GITHUB_TOKEN}}
         script: |
+          const core = require('@actions/core')
           const fs = require('fs');
           const runnerVersion = fs.readFileSync('${{ github.workspace }}/src/runnerversion', 'utf8').replace(/\n$/g, '')
           var releaseNote = fs.readFileSync('${{ github.workspace }}/releaseNote.md', 'utf8').replace(/<RUNNER_VERSION>/g, runnerVersion)
@@ -185,11 +253,33 @@ jobs:
           releaseNote = releaseNote.replace(/<LINUX_X64_SHA>/g, '${{needs.build.outputs.linux-x64-sha}}')
           releaseNote = releaseNote.replace(/<LINUX_ARM_SHA>/g, '${{needs.build.outputs.linux-arm-sha}}')
           releaseNote = releaseNote.replace(/<LINUX_ARM64_SHA>/g, '${{needs.build.outputs.linux-arm64-sha}}')
+          releaseNote = releaseNote.replace(/<WIN_X64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.win-x64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<WIN_ARM64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.win-arm64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<OSX_X64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.osx-x64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<OSX_ARM64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.osx-arm64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_X64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.linux-x64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.linux-arm-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.linux-arm64-sha-noexternals}}')
+          releaseNote = releaseNote.replace(/<WIN_X64_SHA_NORUNTIME>/g, '${{needs.build.outputs.win-x64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<WIN_ARM64_SHA_NORUNTIME>/g, '${{needs.build.outputs.win-arm64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<OSX_X64_SHA_NORUNTIME>/g, '${{needs.build.outputs.osx-x64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<OSX_ARM64_SHA_NORUNTIME>/g, '${{needs.build.outputs.osx-arm64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<LINUX_X64_SHA_NORUNTIME>/g, '${{needs.build.outputs.linux-x64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM_SHA_NORUNTIME>/g, '${{needs.build.outputs.linux-arm-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM64_SHA_NORUNTIME>/g, '${{needs.build.outputs.linux-arm64-sha-noruntime}}')
+          releaseNote = releaseNote.replace(/<WIN_X64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.win-x64-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<WIN_ARM64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.win-arm64-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<OSX_X64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.osx-x64-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<OSX_ARM64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.osx-arm64-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_X64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.linux-x64-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.linux-arm-sha-noruntime-noexternals}}')
+          releaseNote = releaseNote.replace(/<LINUX_ARM64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.linux-arm64-sha-noruntime-noexternals}}')
           console.log(releaseNote)
           core.setOutput('version', runnerVersion);
           core.setOutput('note', releaseNote);
 
     - name: Validate Packages HASH
+      working-directory: _package
       run: |
         ls -l
         echo "${{needs.build.outputs.win-x64-sha}}  actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}.zip" | shasum -a 256 -c
@@ -214,93 +304,379 @@ jobs:
 
     # Upload release assets (full runner packages)
     - name: Upload Release Asset (win-x64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}.zip
+        asset_path: ${{ github.workspace }}/_package/actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}.zip
         asset_name: actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}.zip
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (win-arm64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}.zip
+        asset_path: ${{ github.workspace }}/_package/actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}.zip
         asset_name: actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}.zip
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (linux-x64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
+        asset_path: ${{ github.workspace }}/_package/actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_name: actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (osx-x64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
+        asset_path: ${{ github.workspace }}/_package/actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_name: actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (osx-arm64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
+        asset_path: ${{ github.workspace }}/_package/actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_name: actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (linux-arm)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}.tar.gz
+        asset_path: ${{ github.workspace }}/_package/actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_name: actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
     - name: Upload Release Asset (linux-arm64)
-      uses: actions/upload-release-asset@v1.0.2
+      uses: actions/upload-release-asset@v1.0.1
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       with:
         upload_url: ${{ steps.createRelease.outputs.upload_url }}
-        asset_path: ${{ github.workspace }}/actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
+        asset_path: ${{ github.workspace }}/_package/actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
+    # Upload release assets (trim externals)
+    - name: Upload Release Asset (win-x64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noexternals.zip
+        asset_name: actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noexternals.zip
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trim externals)
+    - name: Upload Release Asset (win-arm64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.zip
+        asset_name: actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.zip
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-x64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_name: actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-x64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_name: actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-arm64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_name: actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_name: actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm64-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_externals/actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trim runtime)
+    - name: Upload Release Asset (win-x64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noruntime.zip
+        asset_name: actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noruntime.zip
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trim runtime)
+    - name: Upload Release Asset (win-arm64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.zip
+        asset_name: actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.zip
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-x64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_name: actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-x64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_name: actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-arm64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_name: actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_name: actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm64-noruntime)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime/actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noruntime.tar.gz
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trim runtime and externals)
+    - name: Upload Release Asset (win-x64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.zip
+        asset_name: actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.zip
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trim runtime and externals)
+    - name: Upload Release Asset (win-arm64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.zip
+        asset_name: actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.zip
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-x64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_name: actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-x64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_name: actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-arm64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_name: actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_name: actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm64-noruntime-noexternals)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/_package_trims/trim_runtime_externals/actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-noruntime-noexternals.tar.gz
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trimmedpackages.json)
+    - name: Upload Release Asset (win-x64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/win-x64-trimmedpackages.json
+        asset_name: actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    # Upload release assets (trimmedpackages.json)
+    - name: Upload Release Asset (win-arm64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/win-arm64-trimmedpackages.json
+        asset_name: actions-runner-win-arm64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-x64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/linux-x64-trimmedpackages.json
+        asset_name: actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-x64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/osx-x64-trimmedpackages.json
+        asset_name: actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (osx-arm64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/osx-arm64-trimmedpackages.json
+        asset_name: actions-runner-osx-arm64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/linux-arm-trimmedpackages.json
+        asset_name: actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
+    - name: Upload Release Asset (linux-arm64-trimmedpackages.json)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.createRelease.outputs.upload_url }}
+        asset_path: ${{ github.workspace }}/linux-arm64-trimmedpackages.json
+        asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}-trimmedpackages.json
+        asset_content_type: application/octet-stream
+
   publish-image:
     needs: release
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
-      id-token: write
-      attestations: write
     env:
       REGISTRY: ghcr.io
       IMAGE_NAME: ${{ github.repository_owner }}/actions-runner
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v3
 
       - name: Compute image version
         id: image
-        uses: actions/github-script@v7.0.1
+        uses: actions/github-script@v6
         with:
           script: |
             const fs = require('fs');
@@ -309,10 +685,10 @@ jobs:
             core.setOutput('version', runnerVersion);
 
       - name: Setup Docker buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
 
       - name: Log into registry ${{ env.REGISTRY }}
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
@@ -320,7 +696,7 @@ jobs:
 
       - name: Build and push Docker image
         id: build-and-push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v3
         with:
           context: ./images
           platforms: |
@@ -336,10 +712,3 @@ jobs:
             org.opencontainers.image.source=${{github.server_url}}/${{github.repository}}
             org.opencontainers.image.description=https://github.com/actions/runner/releases/tag/v${{ steps.image.outputs.version }}
             org.opencontainers.image.licenses=MIT
-
-      - name: Generate attestation
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          subject-digest: ${{ steps.build-and-push.outputs.digest }}
-          push-to-registry: true

.github/workflows/stale-bot.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v8
         with:
           stale-issue-message: "This issue is stale because it has been open 365 days with no activity. Remove stale label or comment or this will be closed in 15 days."
           close-issue-message: "This issue was closed because it has been stalled for 15 days with no activity."

.gitignore

@@ -26,5 +26,4 @@ _dotnetsdk
 TestResults
 TestLogs
 .DS_Store
-.mono
 **/*.DotSettings.user

README.md

@@ -12,33 +12,14 @@ The runner is the application that runs a job from a GitHub Actions workflow. It
 
 For more information about installing and using self-hosted runners, see [Adding self-hosted runners](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/adding-self-hosted-runners) and [Using self-hosted runners in a workflow](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/using-self-hosted-runners-in-a-workflow)
 
-## Download and Install
+Runner releases:
 
-![win](docs/res/win_sm.png) **Windows**: [Prerequisites](docs/start/envwin.md) | [Download](https://github.com/actions/runner/releases)  
+![win](docs/res/win_sm.png) [Pre-reqs](docs/start/envwin.md) | [Download](https://github.com/actions/runner/releases)  
 
-![macOS](docs/res/apple_sm.png) **macOS**: [Prerequisites](docs/start/envosx.md) | [Download](https://github.com/actions/runner/releases)  
+![macOS](docs/res/apple_sm.png)  [Pre-reqs](docs/start/envosx.md) | [Download](https://github.com/actions/runner/releases)  
 
-![linux](docs/res/linux_sm.png) **Linux**: [Prerequisites](docs/start/envlinux.md) | [Download](https://github.com/actions/runner/releases)
+![linux](docs/res/linux_sm.png)  [Pre-reqs](docs/start/envlinux.md) | [Download](https://github.com/actions/runner/releases)
 
-## Documentation and Resources
+## Contribute
 
-- 📚 **[Complete Documentation Index](docs/README.md)** - Comprehensive guide to all documentation
-- 📖 **[Contributing Guide](docs/contribute.md)** - Development setup, building, and testing
-- 🔧 **[Automation Scripts](docs/automate.md)** - Automate runner setup and configuration  
-- 🛠️ **[Troubleshooting Guides](docs/checks/README.md)** - Common issues and solutions
-- 🏗️ **[Architecture Decision Records](docs/adrs/README.md)** - Important architectural decisions
-- ⚙️ **Platform Prerequisites:** [Linux](docs/start/envlinux.md) | [Windows](docs/start/envwin.md) | [macOS](docs/start/envosx.md)
-
-## Support and Community
-
-Thank you for your interest in this repository. Please note our current contribution and support guidelines:
-
-**Bug Reports:** You are welcome to report bugs in this repository through Issues.
-
-**Feature Requests:** Please submit feature and enhancement requests on the [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions) page.
-
-**Support Questions:** For help and support, please use our [Community Discussions area](https://github.com/orgs/community/discussions/categories/actions).
-
-**Security Issues:** Please report security vulnerabilities following our [security policy](security.md).
-
-**High Priority Issues:** Critical bugs can be reported through Community Discussions or our [support team](https://support.github.com/contact/bug-report).
+We accept contributions in the form of issues and pull requests. The runner typically requires changes across the entire system and we aim for issues in the runner to be entirely self contained and fixable here. Therefore, we will primarily handle bug issues opened in this repo and we kindly request you to create all feature and enhancement requests on the [GitHub Feedback](https://github.com/community/community/discussions/categories/actions-and-packages) page. [Read more about our guidelines here](docs/contribute.md) before contributing.

docs/README.md

@@ -1,61 +0,0 @@
-# GitHub Actions Runner Documentation
-
-Welcome to the GitHub Actions Runner documentation. This guide will help you get started with self-hosted runners, contribute to the project, and troubleshoot common issues.
-
-## 🚀 Getting Started
-
-### Installation and Setup
-- **[Linux Prerequisites](start/envlinux.md)** - Complete setup guide for Linux systems
-- **[Windows Prerequisites](start/envwin.md)** - Complete setup guide for Windows systems  
-- **[macOS Prerequisites](start/envosx.md)** - Complete setup guide for macOS systems
-
-### Quick Start
-1. Download the [latest runner release](https://github.com/actions/runner/releases)
-2. Follow the platform-specific prerequisites guide above
-3. Configure your runner with `./config.sh` (Linux/macOS) or `.\config.cmd` (Windows)
-4. Start the runner with `./run.sh` (Linux/macOS) or `.\run.cmd` (Windows)
-
-## 🔧 Administration and Automation
-
-- **[Automation Scripts](automate.md)** - Automate runner deployment and management
-- **[Troubleshooting Guides](checks/)** - Common issues and solutions
-
-## 🏗️ Development and Contributing
-
-- **[Contributing Guide](contribute.md)** - Development setup, building, and testing
-- **[Architecture Decision Records](adrs/README.md)** - Important architectural decisions and design patterns
-
-## 📋 Reference Materials
-
-### System Checks and Troubleshooting
-- **[Network Connectivity](checks/network.md)** - Troubleshoot network issues
-- **[Git Configuration](checks/git.md)** - Git-related problems
-- **[Actions Troubleshooting](checks/actions.md)** - Action-specific issues
-- **[SSL Certificate Issues](checks/sslcert.md)** - Certificate and TLS problems
-- **[Node.js Issues](checks/nodejs.md)** - Node.js runtime problems
-- **[Internet Connectivity](checks/internet.md)** - General connectivity issues
-
-### Development Resources
-- **[Visual Studio Code Setup](contribute/vscode.md)** - IDE configuration for development
-- **[Design Documentation](design/)** - Technical design documents
-
-## 🆘 Getting Help
-
-### Community Support
-- **[GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)** - Ask questions and get help from the community
-- **[GitHub Support](https://support.github.com/contact/bug-report)** - Report critical bugs or get professional support
-
-### Reporting Issues
-- **Bug Reports**: Open an issue in this repository
-- **Feature Requests**: Use [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions-and-packages)
-- **Security Issues**: Follow our [security policy](../security.md)
-
-## 📖 Additional Resources
-
-- **[GitHub Actions Documentation](https://docs.github.com/en/actions)** - Official GitHub Actions documentation
-- **[Self-hosted Runners Guide](https://docs.github.com/en/actions/hosting-your-own-runners)** - GitHub's official self-hosted runner documentation
-- **[Runner Releases](https://github.com/actions/runner/releases)** - Download the latest runner versions
-
----
-
-> **Note**: This documentation is maintained by the GitHub Actions team and the community. If you find any issues or have suggestions for improvement, please open an issue or contribute a pull request.

docs/adrs/0276-problem-matchers.md

@@ -250,42 +250,6 @@ Two problem matchers can be used:
 }
 ```
 
-#### Default from path
-
-The problem matcher can specify a `fromPath` property at the top level, which applies when a specific pattern doesn't provide a value for `fromPath`. This is useful for tools that don't include project file information in their output.
-
-For example, given the following compiler output that doesn't include project file information:
-
-```
-ClassLibrary.cs(16,24): warning CS0612: 'ClassLibrary.Helpers.MyHelper.Name' is obsolete
-```
-
-A problem matcher with a default from path can be used:
-
-```json
-{
-    "problemMatcher": [
-        {
-            "owner": "csc-minimal",
-            "fromPath": "ClassLibrary/ClassLibrary.csproj",
-            "pattern": [
-                {
-                    "regexp": "^(.+)\\((\\d+),(\\d+)\\): (error|warning) (.+): (.*)$",
-                    "file": 1,
-                    "line": 2,
-                    "column": 3,
-                    "severity": 4,
-                    "code": 5,
-                    "message": 6
-                }
-            ]
-        }
-    ]
-}
-```
-
-This ensures that the file is rooted to the correct path when there's not enough information in the error messages to extract a `fromPath`.
-
 #### Mitigate regular expression denial of service (ReDos)
 
 If a matcher exceeds a 1 second timeout when processing a line, retry up to two three times total.

docs/adrs/1751-runner-job-hooks.md

@@ -23,7 +23,7 @@ This feature is mainly intended for self hosted runner administrators.
   - `ACTIONS_RUNNER_HOOK_JOB_STARTED`
   - `ACTIONS_RUNNER_HOOK_JOB_COMPLETED`
 
-You can set these variables to the **absolute** path of a `.sh` or `.ps1` file.
+You can set these variables to the **absolute** path of a a `.sh` or `.ps1` file.
 
 We will execute `pwsh` (fallback to `powershell`) or `bash` (fallback to `sh`) as appropriate.
 - `.sh` files will execute with the args `-e {pathtofile}`

docs/automate.md

@@ -76,76 +76,3 @@ Repo level one-liner.  NOTE: replace with yourorg/yourrepo (repo level) or just
 ```bash
 curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/delete.sh | bash -s yourorg/yourrepo runnername
 ```
-
-## Troubleshooting
-
-### Common Issues
-
-#### Permission Denied
-```bash
-# Ensure scripts have execute permissions
-chmod +x ./config.sh ./run.sh
-```
-
-#### PAT Token Issues
-```bash
-# Verify your PAT has the correct scopes:
-# - repo (for repository-level runners)
-# - admin:org (for organization-level runners)
-export RUNNER_CFG_PAT=your_token_here
-echo $RUNNER_CFG_PAT  # Verify it's set
-```
-
-#### Network Connectivity
-```bash
-# Test GitHub connectivity
-curl -H "Authorization: token $RUNNER_CFG_PAT" https://api.github.com/user
-
-# For GitHub Enterprise Server
-curl -H "Authorization: token $RUNNER_CFG_PAT" https://your-github-enterprise/api/v3/user
-```
-
-#### Service Installation Fails
-```bash
-# Check if running as appropriate user
-whoami
-
-# For Linux - ensure systemd is available
-systemctl --version
-
-# For macOS - ensure launchd is available
-launchctl version
-```
-
-#### Runner Registration Fails
-```bash
-# Check if runner already exists
-curl -H "Authorization: token $RUNNER_CFG_PAT" \
-  "https://api.github.com/repos/OWNER/REPO/actions/runners"
-
-# Remove existing runner if needed
-./config.sh remove --token $RUNNER_CFG_PAT
-```
-
-### Getting Help
-
-- **Configuration Issues**: Check the [Prerequisites](start/envlinux.md) for your platform
-- **Network Problems**: Review [network troubleshooting guide](checks/network.md)
-- **General Support**: Visit [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)
-
-### Advanced Examples
-
-#### Organization-level Runner with Custom Labels
-```bash
-export RUNNER_CFG_PAT=your_org_pat
-curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/create-latest-svc.sh | \
-  bash -s -- -s myorg -n prod-runner-1 -l production,linux,docker
-```
-
-#### Repository-level Runner for GitHub Enterprise
-```bash
-export RUNNER_CFG_PAT=your_ghe_pat
-curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/create-latest-svc.sh | \
-  bash -s -- -s myorg/myrepo -g github.company.com -n build-server -u builder
-```
-```

docs/checks/README.md

@@ -1,66 +0,0 @@
-# Troubleshooting Guides
-
-This directory contains troubleshooting guides for common issues you might encounter when setting up or running GitHub Actions self-hosted runners.
-
-## Quick Reference
-
-| Issue Type | Guide | Description |
-|------------|-------|-------------|
-| 🌐 **Network** | [network.md](network.md) | Connection issues, proxy, firewall problems |
-| 🔒 **SSL/TLS** | [sslcert.md](sslcert.md) | Certificate and TLS handshake issues |
-| 📦 **Git** | [git.md](git.md) | Git configuration and repository access |
-| ⚡ **Actions** | [actions.md](actions.md) | Action-specific runtime issues |
-| 🟢 **Node.js** | [nodejs.md](nodejs.md) | Node.js runtime and npm issues |
-| 🌍 **Internet** | [internet.md](internet.md) | General internet connectivity |
-
-## Common First Steps
-
-Before diving into specific guides, try these general troubleshooting steps:
-
-### 1. Check Basic Connectivity
-```bash
-# Test GitHub API access
-curl -I https://api.github.com/
-
-# For GitHub Enterprise Server
-curl -I https://your-github-enterprise.com/api/v3/
-```
-
-### 2. Verify Runner Status
-```bash
-# Check if runner service is running
-./svc.sh status
-
-# View recent logs
-tail -f _diag/Runner_*.log
-```
-
-### 3. Test Runner Configuration
-```bash
-# Re-run configuration
-./config.sh
-
-# Test connection without running
-./run.sh --check
-```
-
-## Getting Additional Help
-
-If these guides don't resolve your issue:
-
-1. **Search existing issues** in the [runner repository](https://github.com/actions/runner/issues)
-2. **Check GitHub Status** at [githubstatus.com](https://githubstatus.com)
-3. **Ask the community** in [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)
-4. **Contact support** for critical issues via [GitHub Support](https://support.github.com/contact)
-
-## Contributing
-
-Found a solution to a common problem not covered here? Consider contributing:
-
-1. Create a new `.md` file for the issue type
-2. Follow the format of existing guides
-3. Submit a pull request with your improvements
-
----
-
-💡 **Tip**: Always check the `_diag/` directory for detailed log files when troubleshooting issues.

docs/checks/actions.md

@@ -7,10 +7,8 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
 
 - For GitHub.com
   - The runner needs to access `https://api.github.com` for downloading actions.
-  - The runner needs to access `https://codeload.github.com` for downloading actions tar.gz/zip.
   - The runner needs to access `https://vstoken.actions.githubusercontent.com/_apis/.../` for requesting an access token.
   - The runner needs to access `https://pipelines.actions.githubusercontent.com/_apis/.../` for receiving workflow jobs.
-  - The runner needs to access `https://results-receiver.actions.githubusercontent.com/.../` for reporting progress and uploading logs during a workflow job execution.
   ---
   **NOTE:** for the full list of domains that are required to be in the firewall allow list refer to the [GitHub self-hosted runners requirements documentation](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners#communication-between-self-hosted-runners-and-github).
 
@@ -18,15 +16,12 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
 
     ```
     curl -v https://api.github.com/zen
-    curl -v https://codeload.github.com/_ping
     curl -v https://vstoken.actions.githubusercontent.com/_apis/health
     curl -v https://pipelines.actions.githubusercontent.com/_apis/health
-    curl -v https://results-receiver.actions.githubusercontent.com/health
     ```
 
 - For GitHub Enterprise Server
   - The runner needs to access `https://[hostname]/api/v3` for downloading actions.
-  - The runner needs to access `https://codeload.[hostname]/_ping` for downloading actions tar.gz/zip.
   - The runner needs to access `https://[hostname]/_services/vstoken/_apis/.../` for requesting an access token.
   - The runner needs to access `https://[hostname]/_services/pipelines/_apis/.../` for receiving workflow jobs.
   
@@ -34,7 +29,6 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
 
     ```
     curl -v https://[hostname]/api/v3/zen
-    curl -v https://codeload.[hostname]/_ping
     curl -v https://[hostname]/_services/vstoken/_apis/health
     curl -v https://[hostname]/_services/pipelines/_apis/health
     ```
@@ -50,10 +44,6 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
 - Ping api.github.com or myGHES.com using dotnet
 - Make HTTP GET to https://api.github.com or https://myGHES.com/api/v3 using dotnet, check response headers contains `X-GitHub-Request-Id`
 ---
-- DNS lookup for codeload.github.com or codeload.myGHES.com using dotnet
-- Ping codeload.github.com or codeload.myGHES.com using dotnet
-- Make HTTP GET to https://codeload.github.com/_ping or https://codeload.myGHES.com/_ping using dotnet, check response headers contains `X-GitHub-Request-Id`
----
 - DNS lookup for vstoken.actions.githubusercontent.com using dotnet
 - Ping vstoken.actions.githubusercontent.com using dotnet
 - Make HTTP GET to https://vstoken.actions.githubusercontent.com/_apis/health or https://myGHES.com/_services/vstoken/_apis/health using dotnet, check response headers contains `x-vss-e2eid`
@@ -62,10 +52,6 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
 - Ping pipelines.actions.githubusercontent.com using dotnet
 - Make HTTP GET to https://pipelines.actions.githubusercontent.com/_apis/health or https://myGHES.com/_services/pipelines/_apis/health using dotnet, check response headers contains `x-vss-e2eid`
 - Make HTTP POST to https://pipelines.actions.githubusercontent.com/_apis/health or https://myGHES.com/_services/pipelines/_apis/health using dotnet, check response headers contains `x-vss-e2eid`
----
-- DNS lookup for results-receiver.actions.githubusercontent.com using dotnet
-- Ping results-receiver.actions.githubusercontent.com using dotnet
-- Make HTTP GET to https://results-receiver.actions.githubusercontent.com/health using dotnet, check response headers contains `X-GitHub-Request-Id`
 
 ## How to fix the issue?
 

docs/checks/network.md

@@ -42,7 +42,6 @@ If you are having trouble connecting, try these steps:
       - https://api.github.com/
       - https://vstoken.actions.githubusercontent.com/_apis/health
       - https://pipelines.actions.githubusercontent.com/_apis/health
-      - https://results-receiver.actions.githubusercontent.com/health
     - For GHES/GHAE
       - https://myGHES.com/_services/vstoken/_apis/health
       - https://myGHES.com/_services/pipelines/_apis/health

docs/checks/nodejs.md

@@ -4,9 +4,9 @@
 
 Make sure the built-in node.js has access to GitHub.com or GitHub Enterprise Server.
 
-The runner carries its own copies of node.js executables under `<runner_root>/externals/node20/` and `<runner_root>/externals/node24/`.
+The runner carries its own copy of node.js executable under `<runner_root>/externals/node16/`.
 
-All javascript base Actions will get executed by the built-in `node` at either `<runner_root>/externals/node20/` or `<runner_root>/externals/node24/` depending on the version specified in the action's metadata.
+All javascript base Actions will get executed by the built-in `node` at `<runner_root>/externals/node16/`.
 
 > Not the `node` from `$PATH`
 

docs/contribute.md

@@ -1,25 +1,6 @@
 # Contributions
 
-## Table of Contents
-
-- [Getting Started](#getting-started)
-- [Issues](#issues)
-- [Enhancements and Feature Requests](#enhancements-and-feature-requests)
-- [Required Dev Dependencies](#required-dev-dependencies)
-- [Quickstart: Run a Job from a Real Repository](#quickstart-run-a-job-from-a-real-repository)
-- [Development Life Cycle](#development-life-cycle)
-  - [Clone Repository](#clone-repository)
-  - [Build Layout](#build-layout)
-  - [Test Layout](#test-layout)
-  - [Configure Runner](#configure-runner)
-  - [Run Runner](#run-runner)
-  - [View Logs](#view-logs)
-- [Editors](#editors)
-- [Styling](#styling)
-
-## Getting Started
-
-We welcome contributions in the form of issues and pull requests. We view the contributions and the process as the same for github and external contributors. Please note the runner typically requires changes across the entire system and we aim for issues in the runner to be entirely self contained and fixable here. Therefore, we will primarily handle bug issues opened in this repo and we kindly request you to create all feature and enhancement requests on the [GitHub Feedback](https://github.com/community/community/discussions/categories/actions-and-packages) page. 
+We welcome contributions in the form of issues and pull requests. We view the contributions and the process as the same for github and external contributors.Please note the runner typically requires changes across the entire system and we aim for issues in the runner to be entirely self contained and fixable here. Therefore, we will primarily handle bug issues opened in this repo and we kindly request you to create all feature and enhancement requests on the [GitHub Feedback](https://github.com/community/community/discussions/categories/actions-and-packages) page. 
 
 > IMPORTANT: Building your own runner is critical for the dev inner loop process when contributing changes.  However, only runners built and distributed by GitHub (releases) are supported in production.  Be aware that workflows and orchestrations run service side with the runner being a remote process to run steps.  For that reason, the service can pull the runner forward so customizations can be lost.
 
@@ -143,8 +124,8 @@ cd runner/_layout
 ./config.(sh/cmd) # configure your custom runner
 ```
 
-You will need the name of your repository and a runner registration token.
-Check the [Quickstart section](#quickstart-run-a-job-from-a-real-repository) if you don't know how to get this token.
+You will need your the name of your repository and a runner registration token.
+Check [Quickstart](##Quickstart:-Run-a-job-from-a-real-repository) if you don't know how to get this token.
 
 These can also be passed down as arguments to `config.(sh/cmd)`:
 ```bash

docs/start/envlinux.md

@@ -4,23 +4,21 @@
 
 ## Supported Distributions and Versions
 
-Please see "[Supported architectures and operating systems for self-hosted runners](https://docs.github.com/en/actions/reference/runners/self-hosted-runners#linux)."
+x64
+  - Red Hat Enterprise Linux 7
+  - CentOS 7
+  - Oracle Linux 7
+  - Fedora 29+
+  - Debian 9+
+  - Ubuntu 16.04+
+  - Linux Mint 18+
+  - openSUSE 15+
+  - SUSE Enterprise Linux (SLES) 12 SP2+
 
-## Quick Setup
-
-The `./config.sh` script will automatically check and guide you through installing .NET dependencies:
-
-```bash
-./config.sh
-# If dependencies are missing, run:
-./bin/installdependencies.sh
-```
-
-## Install .NET Core Linux Dependencies
-
-The `./config.sh` will check .NET Core dependencies during runner configuration.  
-You might see something like this which indicates a dependency is missing:
+## Install .Net Core 3.x Linux Dependencies
 
+The `./config.sh` will check .Net Core 3.x dependencies during runner configuration.  
+You might see something like this which indicate a dependency's missing.
 ```bash
 ./config.sh
     libunwind.so.8 => not found
@@ -28,87 +26,34 @@ You might see something like this which indicates a dependency is missing:
 Dependencies is missing for Dotnet Core 6.0
 Execute ./bin/installdependencies.sh to install any missing Dotnet Core 6.0 dependencies.
 ```
-
 You can easily correct the problem by executing `./bin/installdependencies.sh`.  
 The `installdependencies.sh` script should install all required dependencies on all supported Linux versions  
+> Note: The `installdependencies.sh` script will try to use the default package management mechanism on your Linux flavor (ex. `yum`/`apt-get`/`apt`).
 
-> **Note:** The `installdependencies.sh` script will try to use the default package management mechanism on your Linux flavor (ex. `yum`/`apt-get`/`apt`).
+### Full dependencies list
 
-## Manual Dependency Installation
+Debian based OS (Debian, Ubuntu, Linux Mint)
 
-If the automatic installation doesn't work, you can manually install dependencies using your package manager:
-
-### Debian based OS (Debian, Ubuntu, Linux Mint)
-
-```bash
-sudo apt-get update
-sudo apt-get install -y liblttng-ust1 libkrb5-3 zlib1g libssl1.1 libicu66
-```
-
-**Required packages:**
 - liblttng-ust1 or liblttng-ust0
 - libkrb5-3
 - zlib1g
 - libssl1.1, libssl1.0.2 or libssl1.0.0
 - libicu63, libicu60, libicu57 or libicu55
 
-### Fedora based OS (Fedora, Red Hat Enterprise Linux, CentOS, Oracle Linux 7)
+Fedora based OS (Fedora, Red Hat Enterprise Linux, CentOS, Oracle Linux 7)
 
-```bash
-sudo yum install -y lttng-ust openssl-libs krb5-libs zlib libicu
-# Or for newer systems:
-sudo dnf install -y lttng-ust openssl-libs krb5-libs zlib libicu
-```
-
-**Required packages:**
 - lttng-ust
 - openssl-libs
 - krb5-libs
 - zlib
 - libicu
 
-### SUSE based OS (OpenSUSE, SUSE Enterprise)
+SUSE based OS (OpenSUSE, SUSE Enterprise)
 
-```bash
-sudo zypper install -y lttng-ust libopenssl1_1 krb5 zlib libicu60_2
-```
-
-**Required packages:**
 - lttng-ust
 - libopenssl1_1
 - krb5
 - zlib
 - libicu60_2
 
-## Troubleshooting
-
-### Common Issues
-
-**Permission denied errors:**
-```bash
-sudo chmod +x ./config.sh ./run.sh
-```
-
-**Missing dependencies after installation:**
-```bash
-# Check what's missing
-ldd ./bin/Runner.Listener
-# Reinstall dependencies
-./bin/installdependencies.sh
-```
-
-**SSL/TLS errors:**
-```bash
-# Update certificates
-sudo apt-get update && sudo apt-get install ca-certificates
-# Or for RHEL/CentOS:
-sudo yum update ca-certificates
-```
-
-### Getting Help
-
-- Check our [troubleshooting guide](../checks/README.md)
-- Search [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)
-- Review [common network issues](../checks/network.md)
-
-## [More .NET Core Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites?tabs=netcore2x)
+## [More .Net Core Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites?tabs=netcore2x)

docs/start/envosx.md

@@ -1,136 +1,10 @@
 
 
-# ![osx](../res/apple_med.png) macOS System Prerequisites
+# ![osx](../res/apple_med.png) macOS/OS X System Prerequisites
 
 ## Supported Versions
 
-Please see "[Supported architectures and operating systems for self-hosted runners](https://docs.github.com/en/actions/reference/runners/self-hosted-runners#macos)."
+  - macOS High Sierra (10.13) and later versions
+  - x64 and arm64 (Apple Silicon)
 
-## Quick Setup
-
-1. **Download** the latest runner from [releases](https://github.com/actions/runner/releases)
-2. **Extract** the downloaded archive: `tar xzf actions-runner-osx-x64-*.tar.gz`
-3. **Run** `./config.sh` to configure the runner
-4. **Install** as a service: `sudo ./svc.sh install` and `sudo ./svc.sh start`
-
-## System Requirements
-
-### macOS Version
-- macOS 10.15 (Catalina) or later
-- Both Intel (x64) and Apple Silicon (ARM64) are supported
-
-### Required Tools
-
-#### Homebrew (Recommended)
-Install Homebrew for easy package management:
-```bash
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-```
-
-#### Development Tools
-```bash
-# Install Xcode Command Line Tools
-xcode-select --install
-
-# Install essential development tools via Homebrew
-brew install git curl wget
-```
-
-### .NET Runtime
-- .NET 6.0 runtime (automatically included with the runner)
-
-## Setup Steps
-
-### 1. Download and Extract
-```bash
-# Create runner directory
-mkdir ~/actions-runner && cd ~/actions-runner
-
-# Download latest release (replace with actual version)
-curl -O -L https://github.com/actions/runner/releases/download/v2.xyz.z/actions-runner-osx-x64-2.xyz.z.tar.gz
-
-# Extract
-tar xzf ./actions-runner-osx-x64-2.xyz.z.tar.gz
-```
-
-### 2. Configure
-```bash
-./config.sh --url https://github.com/YOUR_ORG/YOUR_REPO --token YOUR_TOKEN
-```
-
-### 3. Run as Service (macOS)
-```bash
-# Install as launchd service
-sudo ./svc.sh install
-
-# Start the service
-sudo ./svc.sh start
-
-# Check status
-sudo ./svc.sh status
-```
-
-### 4. Run Interactively (Alternative)
-```bash
-./run.sh
-```
-
-## macOS-Specific Considerations
-
-### Security & Privacy
-- Allow the runner executable through macOS Gatekeeper
-- Grant necessary permissions in System Preferences > Security & Privacy
-
-### Code Signing
-For repositories that build macOS applications:
-```bash
-# Install certificates for code signing
-security import developer_certificates.p12 -k ~/Library/Keychains/login.keychain
-```
-
-### Xcode Integration
-If building iOS/macOS apps:
-```bash
-# Install Xcode from App Store or developer portal
-# Set Xcode path
-sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**Permission Denied:**
-```bash
-chmod +x ./config.sh ./run.sh ./svc.sh
-```
-
-**Gatekeeper Issues:**
-```bash
-# Allow unsigned binary to run
-sudo spctl --master-disable
-# Or specifically allow the runner
-sudo spctl --add ./bin/Runner.Listener
-```
-
-**Service Not Starting:**
-```bash
-# Check system logs
-sudo ./svc.sh status
-tail -f ~/Library/Logs/Runner_*.log
-```
-
-**Path Issues:**
-```bash
-# Ensure proper PATH in your shell profile
-echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.zshrc
-source ~/.zshrc
-```
-
-### Getting Help
-
-- Check our [troubleshooting guide](../checks/README.md)
-- Review [common network issues](../checks/network.md)
-- Search [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)
-
-## [More .NET Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/macos-prerequisites?tabs=netcore30)
+## [More .Net Core Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/macos-prerequisites?tabs=netcore30)

docs/start/envwin.md

@@ -2,94 +2,11 @@
 
 ## Supported Versions
 
-Please see "[Supported architectures and operating systems for self-hosted runners](https://docs.github.com/en/actions/reference/runners/self-hosted-runners#windows)."
+ - Windows 7 64-bit
+ - Windows 8.1 64-bit
+ - Windows 10 64-bit
+ - Windows Server 2012 R2 64-bit
+ - Windows Server 2016 64-bit
+ - Windows Server 2019 64-bit
 
-## Quick Setup
-
-1. **Download** the latest runner from [releases](https://github.com/actions/runner/releases)
-2. **Extract** the downloaded archive to your desired directory
-3. **Run** `config.cmd` as Administrator to configure the runner
-4. **Install** as a service (optional): `svc.sh install` and `svc.sh start`
-
-## System Requirements
-
-### .NET Runtime
-- .NET 6.0 runtime (automatically installed with the runner)
-- Windows PowerShell 5.1 or PowerShell Core 6.0+
-
-### Windows Features
-Windows runners require the following components:
-
-```powershell
-# Enable required Windows features (run as Administrator)
-Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
-```
-
-### Visual Studio Build Tools (For builds requiring compilation)
-For repositories that need to compile code, install:
-
-- **Visual Studio 2017 or newer** [Install here](https://visualstudio.microsoft.com)
-- **Visual Studio 2022 17.3 Preview or later** (for ARM64) [Install here](https://docs.microsoft.com/en-us/visualstudio/releases/2022/release-notes-preview)
-
-### Git for Windows
-- **Git for Windows** [Install here](https://git-scm.com/downloads) (required for repository operations)
-
-## Common Setup Steps
-
-### 1. Create Runner Directory
-```cmd
-mkdir C:\actions-runner
-cd C:\actions-runner
-```
-
-### 2. Download and Extract
-```powershell
-# Download latest release
-Invoke-WebRequest -Uri "https://github.com/actions/runner/releases/download/v2.xyz.z/actions-runner-win-x64-2.xyz.z.zip" -OutFile "actions-runner.zip"
-# Extract
-Expand-Archive -Path "actions-runner.zip" -DestinationPath "."
-```
-
-### 3. Configure
-```cmd
-.\config.cmd --url https://github.com/YOUR_ORG/YOUR_REPO --token YOUR_TOKEN
-```
-
-### 4. Run as Service
-```cmd
-# Install service
-.\svc.sh install
-# Start service  
-.\svc.sh start
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**PowerShell Execution Policy:**
-```powershell
-Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
-```
-
-**Windows Defender/Antivirus:**
-- Add runner directory to antivirus exclusions
-- Exclude `Runner.Listener.exe` and `Runner.Worker.exe`
-
-**Firewall Issues:**
-```powershell
-# Allow runner through Windows Firewall
-New-NetFirewallRule -DisplayName "GitHub Actions Runner" -Direction Inbound -Protocol TCP -LocalPort 443 -Action Allow
-```
-
-**Permission Issues:**
-- Run `config.cmd` as Administrator
-- Ensure the runner user has "Log on as a service" rights
-
-### Getting Help
-
-- Check our [troubleshooting guide](../checks/README.md)
-- Review [common issues](../checks/actions.md)
-- Search [GitHub Community Discussions](https://github.com/orgs/community/discussions/categories/actions)
-
-## [More .NET Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/windows-prerequisites?tabs=netcore30)
+## [More .NET Core Prerequisites Information](https://docs.microsoft.com/en-us/dotnet/core/windows-prerequisites?tabs=netcore30)

images/Dockerfile

@@ -1,12 +1,12 @@
 # Source: https://github.com/dotnet/dotnet-docker
-FROM mcr.microsoft.com/dotnet/runtime-deps:8.0-jammy AS build
+FROM mcr.microsoft.com/dotnet/runtime-deps:6.0-jammy as build
 
 ARG TARGETOS
 ARG TARGETARCH
 ARG RUNNER_VERSION
-ARG RUNNER_CONTAINER_HOOKS_VERSION=0.7.0
-ARG DOCKER_VERSION=28.3.2
-ARG BUILDX_VERSION=0.26.1
+ARG RUNNER_CONTAINER_HOOKS_VERSION=0.4.0
+ARG DOCKER_VERSION=24.0.6
+ARG BUILDX_VERSION=0.11.2
 
 RUN apt update -y && apt install curl unzip -y
 
@@ -32,22 +32,16 @@ RUN export RUNNER_ARCH=${TARGETARCH} \
         "https://github.com/docker/buildx/releases/download/v${BUILDX_VERSION}/buildx-v${BUILDX_VERSION}.linux-${TARGETARCH}" \
     && chmod +x /usr/local/lib/docker/cli-plugins/docker-buildx
 
-FROM mcr.microsoft.com/dotnet/runtime-deps:8.0-jammy
+FROM mcr.microsoft.com/dotnet/runtime-deps:6.0-jammy
 
 ENV DEBIAN_FRONTEND=noninteractive
 ENV RUNNER_MANUALLY_TRAP_SIG=1
 ENV ACTIONS_RUNNER_PRINT_LOG_TO_STDOUT=1
-ENV ImageOS=ubuntu22
 
-# 'gpg-agent' and 'software-properties-common' are needed for the 'add-apt-repository' command that follows
-RUN apt update -y \
-    && apt install -y --no-install-recommends sudo lsb-release gpg-agent software-properties-common curl jq unzip \
-    && rm -rf /var/lib/apt/lists/*
-
-# Configure git-core/ppa based on guidance here:  https://git-scm.com/download/linux
-RUN add-apt-repository ppa:git-core/ppa \
-    && apt update -y \
-    && apt install -y git \
+RUN apt-get update -y \
+    && apt-get install -y --no-install-recommends \
+    sudo \
+    lsb-release \
     && rm -rf /var/lib/apt/lists/*
 
 RUN adduser --disabled-password --gecos "" --uid 1001 runner \

releaseNote.md

@@ -1,32 +1,30 @@
 ## What's Changed
-* Update Docker to v28.3.2 and Buildx to v0.26.1 by @github-actions[bot] in https://github.com/actions/runner/pull/3953
-* Fix if statement structure in update script and variable reference by @salmanmkc in https://github.com/actions/runner/pull/3956
-* Add V2 flow for runner deletion by @Samirat in https://github.com/actions/runner/pull/3954
-* Node 20 -> Node 24 migration feature flagging, opt-in and opt-out environment variables by @salmanmkc in https://github.com/actions/runner/pull/3948
-* Update Node20 and Node24 to latest by @djs-intel in https://github.com/actions/runner/pull/3972
-* Redirect supported OS doc section to current public Docs location by @corycalahan in https://github.com/actions/runner/pull/3979
-* Bump Microsoft.NET.Test.Sdk from 17.13.0 to 17.14.1 by @dependabot[bot] in https://github.com/actions/runner/pull/3975
-* Bump Azure.Storage.Blobs from 12.24.0 to 12.25.0 by @dependabot[bot] in https://github.com/actions/runner/pull/3974
-* Bump actions/download-artifact from 4 to 5 by @dependabot[bot] in https://github.com/actions/runner/pull/3973
-* Bump actions/checkout from 4 to 5 by @dependabot[bot] in https://github.com/actions/runner/pull/3982
+* Trim whitespace in `./Misc/contentHash/dotnetRuntime/*` by @TingluoHuang in https://github.com/actions/runner/pull/2915
+* Send os and arch during long poll by @luketomlinson in https://github.com/actions/runner/pull/2913
+* Revert "Update default version to node20 (#2844)" by @takost in https://github.com/actions/runner/pull/2918
+* Fix telemetry publish from JobServerQueue. by @TingluoHuang in https://github.com/actions/runner/pull/2919
+* Use block blob instead of append blob  by @yacaovsnc in https://github.com/actions/runner/pull/2924
+* Provide detail info on untar failures. by @TingluoHuang in https://github.com/actions/runner/pull/2939
+* Bump node.js to 20.8.1 by @TingluoHuang in https://github.com/actions/runner/pull/2945
+* Update dotnet sdk to latest version @6.0.415 by @github-actions in https://github.com/actions/runner/pull/2929
+* Fix typo in log strings by @rajbos in https://github.com/actions/runner/pull/2695
+* feat: add support of arm64 arch runners in service creation script by @tuxity in https://github.com/actions/runner/pull/2606
+* Add `buildx` to images by @ajschmidt8 in https://github.com/actions/runner/pull/2901
 
 ## New Contributors
-* @Samirat made their first contribution in https://github.com/actions/runner/pull/3954
-* @djs-intel made their first contribution in https://github.com/actions/runner/pull/3972
+* @tuxity made their first contribution in https://github.com/actions/runner/pull/2606
 
-**Full Changelog**: https://github.com/actions/runner/compare/v2.327.1...v2.328.0
+**Full Changelog**: https://github.com/actions/runner/compare/v2.310.2...v2.311.0
 
-_Note: Actions Runner follows a progressive release policy, so the latest release might not be available to your enterprise, organization, or repository yet.
-To confirm which version of the Actions Runner you should expect, please view the download instructions for your enterprise, organization, or repository.
+_Note: Actions Runner follows a progressive release policy, so the latest release might not be available to your enterprise, organization, or repository yet. 
+To confirm which version of the Actions Runner you should expect, please view the download instructions for your enterprise, organization, or repository. 
 See https://docs.github.com/en/enterprise-cloud@latest/actions/hosting-your-own-runners/adding-self-hosted-runners_
 
 ## Windows x64
-
 We recommend configuring the runner in a root folder of the Windows drive (e.g. "C:\actions-runner"). This will help avoid issues related to service identity folder permissions and long file path restrictions on Windows.
 
 The following snipped needs to be run on `powershell`:
-
-```powershell
+``` powershell
 # Create a folder under the drive root
 mkdir \actions-runner ; cd \actions-runner
 # Download the latest runner package
@@ -36,13 +34,13 @@ Add-Type -AssemblyName System.IO.Compression.FileSystem ;
 [System.IO.Compression.ZipFile]::ExtractToDirectory("$PWD\actions-runner-win-x64-<RUNNER_VERSION>.zip", "$PWD")
 ```
 
-## Windows arm64
+## [Pre-release] Windows arm64
+**Warning:** Windows arm64 runners are currently in preview status and use [unofficial versions of nodejs](https://unofficial-builds.nodejs.org/). They are not intended for production workflows.
 
 We recommend configuring the runner in a root folder of the Windows drive (e.g. "C:\actions-runner"). This will help avoid issues related to service identity folder permissions and long file path restrictions on Windows.
 
 The following snipped needs to be run on `powershell`:
-
-```powershell
+``` powershell
 # Create a folder under the drive root
 mkdir \actions-runner ; cd \actions-runner
 # Download the latest runner package
@@ -54,7 +52,7 @@ Add-Type -AssemblyName System.IO.Compression.FileSystem ;
 
 ## OSX x64
 
-```bash
+``` bash
 # Create a folder
 mkdir actions-runner && cd actions-runner
 # Download the latest runner package
@@ -65,7 +63,7 @@ tar xzf ./actions-runner-osx-x64-<RUNNER_VERSION>.tar.gz
 
 ## OSX arm64 (Apple silicon)
 
-```bash
+``` bash
 # Create a folder
 mkdir actions-runner && cd actions-runner
 # Download the latest runner package
@@ -76,7 +74,7 @@ tar xzf ./actions-runner-osx-arm64-<RUNNER_VERSION>.tar.gz
 
 ## Linux x64
 
-```bash
+``` bash
 # Create a folder
 mkdir actions-runner && cd actions-runner
 # Download the latest runner package
@@ -87,7 +85,7 @@ tar xzf ./actions-runner-linux-x64-<RUNNER_VERSION>.tar.gz
 
 ## Linux arm64
 
-```bash
+``` bash
 # Create a folder
 mkdir actions-runner && cd actions-runner
 # Download the latest runner package
@@ -98,7 +96,7 @@ tar xzf ./actions-runner-linux-arm64-<RUNNER_VERSION>.tar.gz
 
 ## Linux arm
 
-```bash
+``` bash
 # Create a folder
 mkdir actions-runner && cd actions-runner
 # Download the latest runner package
@@ -108,7 +106,6 @@ tar xzf ./actions-runner-linux-arm-<RUNNER_VERSION>.tar.gz
 ```
 
 ## Using your self hosted runner
-
 For additional details about configuring, running, or shutting down the runner please check out our [product docs.](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/adding-self-hosted-runners)
 
 ## SHA-256 Checksums
@@ -122,3 +119,27 @@ The SHA-256 checksums for the packages included in this build are shown below:
 - actions-runner-linux-x64-<RUNNER_VERSION>.tar.gz <!-- BEGIN SHA linux-x64 --><LINUX_X64_SHA><!-- END SHA linux-x64 -->
 - actions-runner-linux-arm64-<RUNNER_VERSION>.tar.gz <!-- BEGIN SHA linux-arm64 --><LINUX_ARM64_SHA><!-- END SHA linux-arm64 -->
 - actions-runner-linux-arm-<RUNNER_VERSION>.tar.gz <!-- BEGIN SHA linux-arm --><LINUX_ARM_SHA><!-- END SHA linux-arm -->
+
+- actions-runner-win-x64-<RUNNER_VERSION>-noexternals.zip <!-- BEGIN SHA win-x64_noexternals --><WIN_X64_SHA_NOEXTERNALS><!-- END SHA win-x64_noexternals -->
+- actions-runner-win-arm64-<RUNNER_VERSION>-noexternals.zip <!-- BEGIN SHA win-arm64_noexternals --><WIN_ARM64_SHA_NOEXTERNALS><!-- END SHA win-arm64_noexternals -->
+- actions-runner-osx-x64-<RUNNER_VERSION>-noexternals.tar.gz <!-- BEGIN SHA osx-x64_noexternals --><OSX_X64_SHA_NOEXTERNALS><!-- END SHA osx-x64_noexternals -->
+- actions-runner-osx-arm64-<RUNNER_VERSION>-noexternals.tar.gz <!-- BEGIN SHA osx-arm64_noexternals --><OSX_ARM64_SHA_NOEXTERNALS><!-- END SHA osx-arm64_noexternals -->
+- actions-runner-linux-x64-<RUNNER_VERSION>-noexternals.tar.gz <!-- BEGIN SHA linux-x64_noexternals --><LINUX_X64_SHA_NOEXTERNALS><!-- END SHA linux-x64_noexternals -->
+- actions-runner-linux-arm64-<RUNNER_VERSION>-noexternals.tar.gz <!-- BEGIN SHA linux-arm64_noexternals --><LINUX_ARM64_SHA_NOEXTERNALS><!-- END SHA linux-arm64_noexternals -->
+- actions-runner-linux-arm-<RUNNER_VERSION>-noexternals.tar.gz <!-- BEGIN SHA linux-arm_noexternals --><LINUX_ARM_SHA_NOEXTERNALS><!-- END SHA linux-arm_noexternals -->
+
+- actions-runner-win-x64-<RUNNER_VERSION>-noruntime.zip <!-- BEGIN SHA win-x64_noruntime --><WIN_X64_SHA_NORUNTIME><!-- END SHA win-x64_noruntime -->
+- actions-runner-win-arm64-<RUNNER_VERSION>-noruntime.zip <!-- BEGIN SHA win-arm64_noruntime --><WIN_ARM64_SHA_NORUNTIME><!-- END SHA win-arm64_noruntime -->
+- actions-runner-osx-x64-<RUNNER_VERSION>-noruntime.tar.gz <!-- BEGIN SHA osx-x64_noruntime --><OSX_X64_SHA_NORUNTIME><!-- END SHA osx-x64_noruntime -->
+- actions-runner-osx-arm64-<RUNNER_VERSION>-noruntime.tar.gz <!-- BEGIN SHA osx-arm64_noruntime --><OSX_ARM64_SHA_NORUNTIME><!-- END SHA osx-arm64_noruntime -->
+- actions-runner-linux-x64-<RUNNER_VERSION>-noruntime.tar.gz <!-- BEGIN SHA linux-x64_noruntime --><LINUX_X64_SHA_NORUNTIME><!-- END SHA linux-x64_noruntime -->
+- actions-runner-linux-arm64-<RUNNER_VERSION>-noruntime.tar.gz <!-- BEGIN SHA linux-arm64_noruntime --><LINUX_ARM64_SHA_NORUNTIME><!-- END SHA linux-arm64_noruntime -->
+- actions-runner-linux-arm-<RUNNER_VERSION>-noruntime.tar.gz <!-- BEGIN SHA linux-arm_noruntime --><LINUX_ARM_SHA_NORUNTIME><!-- END SHA linux-arm_noruntime -->
+
+- actions-runner-win-x64-<RUNNER_VERSION>-noruntime-noexternals.zip <!-- BEGIN SHA win-x64_noruntime_noexternals --><WIN_X64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA win-x64_noruntime_noexternals -->
+- actions-runner-win-arm64-<RUNNER_VERSION>-noruntime-noexternals.zip <!-- BEGIN SHA win-arm64_noruntime_noexternals --><WIN_ARM64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA win-arm64_noruntime_noexternals -->
+- actions-runner-osx-x64-<RUNNER_VERSION>-noruntime-noexternals.tar.gz <!-- BEGIN SHA osx-x64_noruntime_noexternals --><OSX_X64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA osx-x64_noruntime_noexternals -->
+- actions-runner-osx-arm64-<RUNNER_VERSION>-noruntime-noexternals.tar.gz <!-- BEGIN SHA osx-arm64_noruntime_noexternals --><OSX_ARM64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA osx-arm64_noruntime_noexternals -->
+- actions-runner-linux-x64-<RUNNER_VERSION>-noruntime-noexternals.tar.gz <!-- BEGIN SHA linux-x64_noruntime_noexternals --><LINUX_X64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA linux-x64_noruntime_noexternals -->
+- actions-runner-linux-arm64-<RUNNER_VERSION>-noruntime-noexternals.tar.gz <!-- BEGIN SHA linux-arm64_noruntime_noexternals --><LINUX_ARM64_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA linux-arm64_noruntime_noexternals -->
+- actions-runner-linux-arm-<RUNNER_VERSION>-noruntime-noexternals.tar.gz <!-- BEGIN SHA linux-arm_noruntime_noexternals --><LINUX_ARM_SHA_NORUNTIME_NOEXTERNALS><!-- END SHA linux-arm_noruntime_noexternals -->

src/Directory.Build.props

@@ -57,13 +57,4 @@
   <PropertyGroup>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
-
-  <PropertyGroup>
-    <!-- Enable NuGet package auditing -->
-    <NuGetAudit>true</NuGetAudit>
-    <!-- Audit direct and transitive packages -->
-    <NuGetAuditMode>all</NuGetAuditMode>
-    <!-- Report low, moderate, high and critical advisories -->
-    <NuGetAuditLevel>moderate</NuGetAuditLevel>
-  </PropertyGroup>
 </Project>

src/Misc/contentHash/dotnetRuntime/linux-arm

@@ -0,0 +1 @@
+531b31914e525ecb12cc5526415bc70a112ebc818f877347af1a231011f539c5

src/Misc/contentHash/dotnetRuntime/linux-arm64

@@ -0,0 +1 @@
+722dd5fa5ecc207fcccf67f6e502d689f2119d8117beff2041618fba17dc66a4

src/Misc/contentHash/dotnetRuntime/linux-x64

@@ -0,0 +1 @@
+8ca75c76e15ab9dc7fe49a66c5c74e171e7fabd5d26546fda8931bd11bff30f9

src/Misc/contentHash/dotnetRuntime/osx-arm64

@@ -0,0 +1 @@
+70496eb1c99b39b3373b5088c95a35ebbaac1098e6c47c8aab94771f3ffbf501

src/Misc/contentHash/dotnetRuntime/osx-x64

@@ -0,0 +1 @@
+4f8d48727d535daabcaec814e0dafb271c10625366c78e7e022ca7477a73023f

src/Misc/contentHash/dotnetRuntime/win-arm64

@@ -0,0 +1 @@
+d54d7428f2b9200a0030365a6a4e174e30a1b29b922f8254dffb2924bd09549d

src/Misc/contentHash/dotnetRuntime/win-x64

@@ -0,0 +1 @@
+eaa939c45307f46b7003902255b3a2a09287215d710984107667e03ac493eb26

src/Misc/contentHash/externals/linux-arm

@@ -0,0 +1 @@
+4bf3e1af0d482af1b2eaf9f08250248a8c1aea8ec20a3c5be116d58cdd930009

src/Misc/contentHash/externals/linux-arm64

@@ -0,0 +1 @@
+ec1719a8cb4d8687328aa64f4aa7c4e3498a715d8939117874782e3e6e63a14b

src/Misc/contentHash/externals/linux-x64

@@ -0,0 +1 @@
+50538de29f173bb73f708c4ed2c8328a62b8795829b97b2a6cb57197e2305287

src/Misc/contentHash/externals/osx-arm64

@@ -0,0 +1 @@
+a0a96cbb7593643b69e669bf14d7b29b7f27800b3a00bb3305aebe041456c701

src/Misc/contentHash/externals/osx-x64

@@ -0,0 +1 @@
+6255b22692779467047ecebd60ad46984866d75cdfe10421d593a7b51d620b09

src/Misc/contentHash/externals/win-arm64

@@ -0,0 +1 @@
+6ff1abd055dc35bfbf06f75c2f08908f660346f66ad1d8f81c910068e9ba029d

src/Misc/contentHash/externals/win-x64

@@ -0,0 +1 @@
+433a6d748742d12abd20dc2a79b62ac3d9718ae47ef26f8e84dc8c180eea3659

src/Misc/expressionFunc/hashFiles/package.json

@@ -11,6 +11,7 @@
     "pack": "ncc build -o ../../layoutbin/hashFiles",
     "all": "npm run format && npm run lint && npm run build && npm run pack",
     "prepare": "cd ../../../../ && husky install"
+
   },
   "repository": {
     "type": "git",
@@ -42,9 +43,9 @@
     "eslint": "^8.47.0",
     "eslint-plugin-github": "^4.10.0",
     "eslint-plugin-prettier": "^5.0.0",
-    "husky": "^8.0.3",
-    "lint-staged": "^15.5.0",
     "prettier": "^3.0.3",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "husky": "^8.0.3",
+    "lint-staged": "^14.0.0"
   }
-}
+}

src/Misc/externals.sh

@@ -3,11 +3,12 @@ PACKAGERUNTIME=$1
 PRECACHE=$2
 
 NODE_URL=https://nodejs.org/dist
+UNOFFICIAL_NODE_URL=https://unofficial-builds.nodejs.org/download/release
 NODE_ALPINE_URL=https://github.com/actions/alpine_nodejs/releases/download
-# When you update Node versions you must also create a new release of alpine_nodejs at that updated version.
-# Follow the instructions here: https://github.com/actions/alpine_nodejs?tab=readme-ov-file#getting-started
-NODE20_VERSION="20.19.4"
-NODE24_VERSION="24.5.0"
+NODE16_VERSION="16.20.2"
+NODE20_VERSION="20.8.1"
+# used only for win-arm64, remove node16 unofficial version when official version is available
+NODE16_UNOFFICIAL_VERSION="16.20.0"
 
 get_abs_path() {
   # exploits the fact that pwd will print abs path when no args
@@ -62,16 +63,17 @@ function acquireExternalTool() {
             echo "Curl version: $CURL_VERSION"
 
             # curl -f Fail silently (no output at all) on HTTP errors (H)
+            #      -k Allow connections to SSL sites without certs (H)
             #      -S Show error. With -s, make curl show errors when they occur
             #      -L Follow redirects (H)
             #      -o FILE    Write to FILE instead of stdout
             #      --retry 3   Retries transient errors 3 times (timeouts, 5xx)
             if [[ "$(printf '%s\n' "7.71.0" "$CURL_VERSION" | sort -V | head -n1)" != "7.71.0" ]]; then
                 # Curl version is less than or equal to 7.71.0, skipping retry-all-errors flag
-                 curl -fSL --retry 3 -o "$partial_target" "$download_source" 2>"${download_target}_download.log" || checkRC 'curl'
+                 curl -fkSL --retry 3 -o "$partial_target" "$download_source" 2>"${download_target}_download.log" || checkRC 'curl'
             else
                 # Curl version is greater than 7.71.0, running curl with --retry-all-errors flag
-                 curl -fSL --retry 3 --retry-all-errors -o "$partial_target" "$download_source" 2>"${download_target}_download.log" || checkRC 'curl'
+                 curl -fkSL --retry 3 --retry-all-errors -o "$partial_target" "$download_source" 2>"${download_target}_download.log" || checkRC 'curl'
             fi
 
             # Move the partial file to the download target.
@@ -138,10 +140,10 @@ function acquireExternalTool() {
 
 # Download the external tools only for Windows.
 if [[ "$PACKAGERUNTIME" == "win-x64" || "$PACKAGERUNTIME" == "win-x86" ]]; then
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/$PACKAGERUNTIME/node.exe" node16/bin
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/$PACKAGERUNTIME/node.lib" node16/bin
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.exe" node20/bin
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.lib" node20/bin
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.exe" node24/bin
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.lib" node24/bin
     if [[ "$PRECACHE" != "" ]]; then
         acquireExternalTool "https://github.com/microsoft/vswhere/releases/download/2.6.7/vswhere.exe" vswhere
     fi
@@ -150,10 +152,10 @@ fi
 # Download the external tools only for Windows.
 if [[ "$PACKAGERUNTIME" == "win-arm64" ]]; then
     # todo: replace these with official release when available
+    acquireExternalTool "$UNOFFICIAL_NODE_URL/v${NODE16_UNOFFICIAL_VERSION}/$PACKAGERUNTIME/node.exe" node16/bin
+    acquireExternalTool "$UNOFFICIAL_NODE_URL/v${NODE16_UNOFFICIAL_VERSION}/$PACKAGERUNTIME/node.lib" node16/bin
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.exe" node20/bin
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/$PACKAGERUNTIME/node.lib" node20/bin
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.exe" node24/bin
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/$PACKAGERUNTIME/node.lib" node24/bin
     if [[ "$PRECACHE" != "" ]]; then
         acquireExternalTool "https://github.com/microsoft/vswhere/releases/download/2.6.7/vswhere.exe" vswhere
     fi
@@ -161,29 +163,30 @@ fi
 
 # Download the external tools only for OSX.
 if [[ "$PACKAGERUNTIME" == "osx-x64" ]]; then
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-darwin-x64.tar.gz" node16 fix_nested_dir
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-darwin-x64.tar.gz" node20 fix_nested_dir
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-darwin-x64.tar.gz" node24 fix_nested_dir
 fi
 
 if [[ "$PACKAGERUNTIME" == "osx-arm64" ]]; then
     # node.js v12 doesn't support macOS on arm64.
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-darwin-arm64.tar.gz" node16 fix_nested_dir
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-darwin-arm64.tar.gz" node20 fix_nested_dir
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-darwin-arm64.tar.gz" node24 fix_nested_dir
 fi
 
 # Download the external tools for Linux PACKAGERUNTIMEs.
 if [[ "$PACKAGERUNTIME" == "linux-x64" ]]; then
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-linux-x64.tar.gz" node16 fix_nested_dir
+    acquireExternalTool "$NODE_ALPINE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-alpine-x64.tar.gz" node16_alpine
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-linux-x64.tar.gz" node20 fix_nested_dir
     acquireExternalTool "$NODE_ALPINE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-alpine-x64.tar.gz" node20_alpine
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-linux-x64.tar.gz" node24 fix_nested_dir
-    acquireExternalTool "$NODE_ALPINE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-alpine-x64.tar.gz" node24_alpine
 fi
 
 if [[ "$PACKAGERUNTIME" == "linux-arm64" ]]; then
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-linux-arm64.tar.gz" node16 fix_nested_dir
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-linux-arm64.tar.gz" node20 fix_nested_dir
-    acquireExternalTool "$NODE_URL/v${NODE24_VERSION}/node-v${NODE24_VERSION}-linux-arm64.tar.gz" node24 fix_nested_dir
 fi
 
 if [[ "$PACKAGERUNTIME" == "linux-arm" ]]; then
+    acquireExternalTool "$NODE_URL/v${NODE16_VERSION}/node-v${NODE16_VERSION}-linux-armv7l.tar.gz" node16 fix_nested_dir
     acquireExternalTool "$NODE_URL/v${NODE20_VERSION}/node-v${NODE20_VERSION}-linux-armv7l.tar.gz" node20 fix_nested_dir
 fi

src/Misc/layoutbin/RunnerService.js

@@ -114,11 +114,6 @@ var runService = function () {
             );
             stopping = true;
           }
-        } else if (code === 5) {
-          console.log(
-            "Runner listener exit with Session Conflict error, stop the service, no retry needed."
-          );
-          stopping = true;
         } else {
           var messagePrefix = "Runner listener exit with undefined return code";
           unknownFailureRetryCount++;

src/Misc/layoutbin/hashFiles/index.js

@@ -3299,7 +3299,7 @@ function expand(str, isTop) {
   var isOptions = m.body.indexOf(',') >= 0;
   if (!isSequence && !isOptions) {
     // {a},b}
-    if (m.post.match(/,(?!,).*\}/)) {
+    if (m.post.match(/,.*\}/)) {
       str = m.pre + '{' + m.body + escClose + m.post;
       return expand(str);
     }

src/Misc/layoutbin/runsvc.sh

@@ -10,7 +10,7 @@ if [ -f ".path" ]; then
     echo ".path=${PATH}"
 fi
 
-nodever="node20"
+nodever=${GITHUB_ACTIONS_RUNNER_FORCED_NODE_VERSION:-node16}
 
 # insert anything to setup env when running as a service
 # run the host process which keep the listener alive

src/Misc/layoutbin/update.sh.template

@@ -123,7 +123,7 @@ fi
 # fix upgrade issue with macOS when running as a service
 attemptedtargetedfix=0
 currentplatform=$(uname | awk '{print tolower($0)}')
-if [[ "$currentplatform" == 'darwin'  && $restartinteractiverunner -eq 0 ]]; then
+if [[ "$currentplatform" == 'darwin'  && restartinteractiverunner -eq 0 ]]; then
     # We needed a fix for https://github.com/actions/runner/issues/743
     # We will recreate the ./externals/nodeXY/bin/node of the past runner version that launched the runnerlistener service
     # Otherwise mac gatekeeper kills the processes we spawn on creation as we are running a process with no backing file
@@ -135,23 +135,12 @@ if [[ "$currentplatform" == 'darwin'  && $restartinteractiverunner -eq 0 ]]; the
     then
         # inspect the open file handles to find the node process
         # we can't actually inspect the process using ps because it uses relative paths and doesn't follow symlinks
-        # Try finding node24 first, then fallback to earlier versions if needed
-        nodever="node24"
+        nodever="node16"
         path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
-        if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node20
+        if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node12
         then
-            nodever="node20"
+            nodever="node12"
             path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
-            if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node16
-            then
-                nodever="node16"
-                path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
-                if [[ $? -ne 0 || -z "$path" ]] # Fallback if RunnerService.js was started with node12
-                then
-                    nodever="node12"
-                    path=$(lsof -a -g "$procgroup" -F n | grep $nodever/bin/node | grep externals | tail -1 | cut -c2-)
-                fi
-            fi
         fi
         if [[ $? -eq 0 && -n "$path" ]]
         then
@@ -189,19 +178,6 @@ if [[ "$currentplatform" == 'darwin'  && $restartinteractiverunner -eq 0 ]]; the
     fi
 fi
 
-# update runsvc.sh
-if [ -f "$rootfolder/runsvc.sh" ]
-then
-    date "+[%F %T-%4N] Update runsvc.sh" >> "$logfile" 2>&1
-    cat "$rootfolder/bin/runsvc.sh" > "$rootfolder/runsvc.sh"
-    if [ $? -ne 0 ]
-    then
-        date "+[%F %T-%4N] Can't update $rootfolder/runsvc.sh using $rootfolder/bin/runsvc.sh" >> "$logfile" 2>&1
-        mv -fv "$logfile" "$logfile.failed"
-        exit 1
-    fi
-fi
-
 date "+[%F %T-%4N] Update succeed" >> "$logfile"
 
 touch update.finished

src/Misc/layoutroot/run-helper.cmd.template

@@ -49,10 +49,5 @@ if %ERRORLEVEL% EQU 4 (
   exit /b 1
 )
 
-if %ERRORLEVEL% EQU 5 (
-  echo "Runner listener exit with Session Conflict error, stop the service, no retry needed."
-  exit /b 0
-)
-
 echo "Exiting after unknown error code: %ERRORLEVEL%"
 exit /b 0

src/Misc/layoutroot/run-helper.sh.template

@@ -70,9 +70,6 @@ elif [[ $returnCode == 4 ]]; then
         "$DIR"/safe_sleep.sh 1
     done
     exit 2
-elif [[ $returnCode == 5 ]]; then
-    echo "Runner listener exit with Session Conflict error, stop the service, no retry needed."
-    exit 0
 else
     echo "Exiting with unknown error code: ${returnCode}"
     exit 0

src/Misc/layoutroot/run.sh

@@ -38,7 +38,7 @@ runWithManualTrap() {
         cp -f "$DIR"/run-helper.sh.template "$DIR"/run-helper.sh
         "$DIR"/run-helper.sh $* &
         PID=$!
-        wait $PID
+        wait -f $PID
         returnCode=$?
         if [[ $returnCode -eq 2 ]]; then
             echo "Restarting runner..."
@@ -84,4 +84,4 @@ if [[ -z "$RUNNER_MANUALLY_TRAP_SIG" ]]; then
     run $*
 else
     runWithManualTrap $*
-fi
+fi

src/Misc/runnercoreassets

@@ -0,0 +1,57 @@
+actions.runner.plist.template
+actions.runner.service.template
+checkScripts/downloadCert.js
+checkScripts/makeWebRequest.js
+darwin.svc.sh.template
+hashFiles/index.js
+installdependencies.sh
+macos-run-invoker.js
+Microsoft.IdentityModel.Logging.dll
+Microsoft.IdentityModel.Tokens.dll
+Minimatch.dll
+Newtonsoft.Json.Bson.dll
+Newtonsoft.Json.dll
+Runner.Common.deps.json
+Runner.Common.dll
+Runner.Common.pdb
+Runner.Listener
+Runner.Listener.deps.json
+Runner.Listener.dll
+Runner.Listener.exe
+Runner.Listener.pdb
+Runner.Listener.runtimeconfig.json
+Runner.PluginHost
+Runner.PluginHost.deps.json
+Runner.PluginHost.dll
+Runner.PluginHost.exe
+Runner.PluginHost.pdb
+Runner.PluginHost.runtimeconfig.json
+Runner.Plugins.deps.json
+Runner.Plugins.dll
+Runner.Plugins.pdb
+Runner.Sdk.deps.json
+Runner.Sdk.dll
+Runner.Sdk.pdb
+Runner.Worker
+Runner.Worker.deps.json
+Runner.Worker.dll
+Runner.Worker.exe
+Runner.Worker.pdb
+Runner.Worker.runtimeconfig.json
+RunnerService.exe
+RunnerService.exe.config
+RunnerService.js
+RunnerService.pdb
+runsvc.sh
+Sdk.deps.json
+Sdk.dll
+Sdk.pdb
+System.IdentityModel.Tokens.Jwt.dll
+System.Net.Http.Formatting.dll
+System.Security.Cryptography.Pkcs.dll
+System.Security.Cryptography.ProtectedData.dll
+System.ServiceProcess.ServiceController.dll
+systemd.svc.sh.template
+update.cmd.template
+update.sh.template
+YamlDotNet.dll

src/Misc/runnerdotnetruntimeassets

@@ -0,0 +1,270 @@
+api-ms-win-core-console-l1-1-0.dll
+api-ms-win-core-console-l1-2-0.dll
+api-ms-win-core-datetime-l1-1-0.dll
+api-ms-win-core-debug-l1-1-0.dll
+api-ms-win-core-errorhandling-l1-1-0.dll
+api-ms-win-core-fibers-l1-1-0.dll
+api-ms-win-core-file-l1-1-0.dll
+api-ms-win-core-file-l1-2-0.dll
+api-ms-win-core-file-l2-1-0.dll
+api-ms-win-core-handle-l1-1-0.dll
+api-ms-win-core-heap-l1-1-0.dll
+api-ms-win-core-interlocked-l1-1-0.dll
+api-ms-win-core-libraryloader-l1-1-0.dll
+api-ms-win-core-localization-l1-2-0.dll
+api-ms-win-core-memory-l1-1-0.dll
+api-ms-win-core-namedpipe-l1-1-0.dll
+api-ms-win-core-processenvironment-l1-1-0.dll
+api-ms-win-core-processthreads-l1-1-0.dll
+api-ms-win-core-processthreads-l1-1-1.dll
+api-ms-win-core-profile-l1-1-0.dll
+api-ms-win-core-rtlsupport-l1-1-0.dll
+api-ms-win-core-string-l1-1-0.dll
+api-ms-win-core-synch-l1-1-0.dll
+api-ms-win-core-synch-l1-2-0.dll
+api-ms-win-core-sysinfo-l1-1-0.dll
+api-ms-win-core-timezone-l1-1-0.dll
+api-ms-win-core-util-l1-1-0.dll
+api-ms-win-crt-conio-l1-1-0.dll
+api-ms-win-crt-convert-l1-1-0.dll
+api-ms-win-crt-environment-l1-1-0.dll
+api-ms-win-crt-filesystem-l1-1-0.dll
+api-ms-win-crt-heap-l1-1-0.dll
+api-ms-win-crt-locale-l1-1-0.dll
+api-ms-win-crt-math-l1-1-0.dll
+api-ms-win-crt-multibyte-l1-1-0.dll
+api-ms-win-crt-private-l1-1-0.dll
+api-ms-win-crt-process-l1-1-0.dll
+api-ms-win-crt-runtime-l1-1-0.dll
+api-ms-win-crt-stdio-l1-1-0.dll
+api-ms-win-crt-string-l1-1-0.dll
+api-ms-win-crt-time-l1-1-0.dll
+api-ms-win-crt-utility-l1-1-0.dll
+clrcompression.dll
+clretwrc.dll
+clrjit.dll
+coreclr.dll
+createdump
+createdump.exe
+dbgshim.dll
+hostfxr.dll
+hostpolicy.dll
+libclrjit.dylib
+libclrjit.so
+libcoreclr.dylib
+libcoreclr.so
+libcoreclrtraceptprovider.so
+libdbgshim.dylib
+libdbgshim.so
+libhostfxr.dylib
+libhostfxr.so
+libhostpolicy.dylib
+libhostpolicy.so
+libmscordaccore.dylib
+libmscordaccore.so
+libmscordbi.dylib
+libmscordbi.so
+Microsoft.CSharp.dll
+Microsoft.DiaSymReader.Native.amd64.dll
+Microsoft.DiaSymReader.Native.arm64.dll
+Microsoft.VisualBasic.Core.dll
+Microsoft.VisualBasic.dll
+Microsoft.Win32.Primitives.dll
+Microsoft.Win32.Registry.dll
+mscordaccore.dll
+mscordaccore_amd64_amd64_6.0.522.21309.dll
+mscordaccore_arm64_arm64_6.0.522.21309.dll
+mscordaccore_amd64_amd64_6.0.1322.58009.dll
+mscordaccore_amd64_amd64_6.0.2023.32017.dll
+mscordaccore_amd64_amd64_6.0.2223.42425.dll
+mscordaccore_amd64_amd64_6.0.2323.48002.dll
+mscordbi.dll
+mscorlib.dll
+mscorrc.debug.dll
+mscorrc.dll
+msquic.dll
+netstandard.dll
+SOS_README.md
+System.AppContext.dll
+System.Buffers.dll
+System.Collections.Concurrent.dll
+System.Collections.dll
+System.Collections.Immutable.dll
+System.Collections.NonGeneric.dll
+System.Collections.Specialized.dll
+System.ComponentModel.Annotations.dll
+System.ComponentModel.DataAnnotations.dll
+System.ComponentModel.dll
+System.ComponentModel.EventBasedAsync.dll
+System.ComponentModel.Primitives.dll
+System.ComponentModel.TypeConverter.dll
+System.Configuration.dll
+System.Console.dll
+System.Core.dll
+System.Data.Common.dll
+System.Data.DataSetExtensions.dll
+System.Data.dll
+System.Diagnostics.Contracts.dll
+System.Diagnostics.Debug.dll
+System.Diagnostics.DiagnosticSource.dll
+System.Diagnostics.FileVersionInfo.dll
+System.Diagnostics.Process.dll
+System.Diagnostics.StackTrace.dll
+System.Diagnostics.TextWriterTraceListener.dll
+System.Diagnostics.Tools.dll
+System.Diagnostics.TraceSource.dll
+System.Diagnostics.Tracing.dll
+System.dll
+System.Drawing.dll
+System.Drawing.Primitives.dll
+System.Dynamic.Runtime.dll
+System.Formats.Asn1.dll
+System.Globalization.Calendars.dll
+System.Globalization.dll
+System.Globalization.Extensions.dll
+System.Globalization.Native.dylib
+System.Globalization.Native.so
+System.IO.Compression.Brotli.dll
+System.IO.Compression.dll
+System.IO.Compression.FileSystem.dll
+System.IO.Compression.Native.a
+System.IO.Compression.Native.dll
+System.IO.Compression.Native.dylib
+System.IO.Compression.Native.so
+System.IO.Compression.ZipFile.dll
+System.IO.dll
+System.IO.FileSystem.AccessControl.dll
+System.IO.FileSystem.dll
+System.IO.FileSystem.DriveInfo.dll
+System.IO.FileSystem.Primitives.dll
+System.IO.FileSystem.Watcher.dll
+System.IO.IsolatedStorage.dll
+System.IO.MemoryMappedFiles.dll
+System.IO.Pipes.AccessControl.dll
+System.IO.Pipes.dll
+System.IO.UnmanagedMemoryStream.dll
+System.Linq.dll
+System.Linq.Expressions.dll
+System.Linq.Parallel.dll
+System.Linq.Queryable.dll
+System.Memory.dll
+System.Native.a
+System.Native.dylib
+System.Native.so
+System.Net.dll
+System.Net.Http.dll
+System.Net.Http.Json.dll
+System.Net.Http.Native.a
+System.Net.Http.Native.dylib
+System.Net.Http.Native.so
+System.Net.HttpListener.dll
+System.Net.Mail.dll
+System.Net.NameResolution.dll
+System.Net.NetworkInformation.dll
+System.Net.Ping.dll
+System.Net.Primitives.dll
+System.Net.Quic.dll
+System.Net.Requests.dll
+System.Net.Security.dll
+System.Net.Security.Native.a
+System.Net.Security.Native.dylib
+System.Net.Security.Native.so
+System.Net.ServicePoint.dll
+System.Net.Sockets.dll
+System.Net.WebClient.dll
+System.Net.WebHeaderCollection.dll
+System.Net.WebProxy.dll
+System.Net.WebSockets.Client.dll
+System.Net.WebSockets.dll
+System.Numerics.dll
+System.Numerics.Vectors.dll
+System.ObjectModel.dll
+System.Private.CoreLib.dll
+System.Private.DataContractSerialization.dll
+System.Private.Uri.dll
+System.Private.Xml.dll
+System.Private.Xml.Linq.dll
+System.Reflection.DispatchProxy.dll
+System.Reflection.dll
+System.Reflection.Emit.dll
+System.Reflection.Emit.ILGeneration.dll
+System.Reflection.Emit.Lightweight.dll
+System.Reflection.Extensions.dll
+System.Reflection.Metadata.dll
+System.Reflection.Primitives.dll
+System.Reflection.TypeExtensions.dll
+System.Resources.Reader.dll
+System.Resources.ResourceManager.dll
+System.Resources.Writer.dll
+System.Runtime.CompilerServices.Unsafe.dll
+System.Runtime.CompilerServices.VisualC.dll
+System.Runtime.dll
+System.Runtime.Extensions.dll
+System.Runtime.Handles.dll
+System.Runtime.InteropServices.dll
+System.Runtime.InteropServices.RuntimeInformation.dll
+System.Runtime.InteropServices.WindowsRuntime.dll
+System.Runtime.Intrinsics.dll
+System.Runtime.Loader.dll
+System.Runtime.Numerics.dll
+System.Runtime.Serialization.dll
+System.Runtime.Serialization.Formatters.dll
+System.Runtime.Serialization.Json.dll
+System.Runtime.Serialization.Primitives.dll
+System.Runtime.Serialization.Xml.dll
+System.Runtime.WindowsRuntime.dll
+System.Runtime.WindowsRuntime.UI.Xaml.dll
+System.Security.AccessControl.dll
+System.Security.Claims.dll
+System.Security.Cryptography.Algorithms.dll
+System.Security.Cryptography.Cng.dll
+System.Security.Cryptography.Csp.dll
+System.Security.Cryptography.Encoding.dll
+System.Security.Cryptography.Native.Apple.a
+System.Security.Cryptography.Native.Apple.dylib
+System.Security.Cryptography.Native.OpenSsl.a
+System.Security.Cryptography.Native.OpenSsl.dylib
+System.Security.Cryptography.Native.OpenSsl.so
+System.Security.Cryptography.OpenSsl.dll
+System.Security.Cryptography.Primitives.dll
+System.Security.Cryptography.X509Certificates.dll
+System.Security.Cryptography.XCertificates.dll
+System.Security.dll
+System.Security.Principal.dll
+System.Security.Principal.Windows.dll
+System.Security.SecureString.dll
+System.ServiceModel.Web.dll
+System.ServiceProcess.dll
+System.Text.Encoding.CodePages.dll
+System.Text.Encoding.dll
+System.Text.Encoding.Extensions.dll
+System.Text.Encodings.Web.dll
+System.Text.Json.dll
+System.Text.RegularExpressions.dll
+System.Threading.Channels.dll
+System.Threading.dll
+System.Threading.Overlapped.dll
+System.Threading.Tasks.Dataflow.dll
+System.Threading.Tasks.dll
+System.Threading.Tasks.Extensions.dll
+System.Threading.Tasks.Parallel.dll
+System.Threading.Thread.dll
+System.Threading.ThreadPool.dll
+System.Threading.Timer.dll
+System.Transactions.dll
+System.Transactions.Local.dll
+System.ValueTuple.dll
+System.Web.dll
+System.Web.HttpUtility.dll
+System.Windows.dll
+System.Xml.dll
+System.Xml.Linq.dll
+System.Xml.ReaderWriter.dll
+System.Xml.Serialization.dll
+System.Xml.XDocument.dll
+System.Xml.XmlDocument.dll
+System.Xml.XmlSerializer.dll
+System.Xml.XPath.dll
+System.Xml.XPath.XDocument.dll
+ucrtbase.dll
+WindowsBase.dll

src/Misc/trimmedpackages_targz.json

@@ -0,0 +1,24 @@
+[
+    {
+        "HashValue": "<NO_RUNTIME_EXTERNALS_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noruntime-noexternals.tar.gz",
+        "TrimmedContents": {
+            "dotnetRuntime": "<RUNTIME_HASH>",
+            "externals": "<EXTERNALS_HASH>"
+        }
+    },
+    {
+        "HashValue": "<NO_RUNTIME_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noruntime.tar.gz",
+        "TrimmedContents": {
+            "dotnetRuntime": "<RUNTIME_HASH>"
+        }
+    },
+    {
+        "HashValue": "<NO_EXTERNALS_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noexternals.tar.gz",
+        "TrimmedContents": {
+            "externals": "<EXTERNALS_HASH>"
+        }
+    }
+]

src/Misc/trimmedpackages_zip.json

@@ -0,0 +1,24 @@
+[
+    {
+        "HashValue": "<NO_RUNTIME_EXTERNALS_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noruntime-noexternals.zip",
+        "TrimmedContents": {
+            "dotnetRuntime": "<RUNTIME_HASH>",
+            "externals": "<EXTERNALS_HASH>"
+        }
+    },
+    {
+        "HashValue": "<NO_RUNTIME_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noruntime.zip",
+        "TrimmedContents": {
+            "dotnetRuntime": "<RUNTIME_HASH>"
+        }
+    },
+    {
+        "HashValue": "<NO_EXTERNALS_HASH>",
+        "DownloadUrl": "https://github.com/actions/runner/releases/download/v<RUNNER_VERSION>/actions-runner-<RUNNER_PLATFORM>-<RUNNER_VERSION>-noexternals.zip",
+        "TrimmedContents": {
+            "externals": "<EXTERNALS_HASH>"
+        }
+    }
+]

src/Runner.Common/ActionsRunServer.cs

@@ -20,12 +20,12 @@ namespace GitHub.Runner.Common
     {
         private bool _hasConnection;
         private VssConnection _connection;
-        private ActionsRunServerHttpClient _actionsRunServerClient;
+        private TaskAgentHttpClient _taskAgentClient;
 
         public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
         {
             _connection = await EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
-            _actionsRunServerClient = _connection.GetClient<ActionsRunServerHttpClient>();
+            _taskAgentClient = _connection.GetClient<TaskAgentHttpClient>();
             _hasConnection = true;
         }
 
@@ -42,7 +42,7 @@ namespace GitHub.Runner.Common
             CheckConnection();
             var jobMessage = RetryRequest<AgentJobRequestMessage>(async () =>
                                                     {
-                                                        return await _actionsRunServerClient.GetJobMessageAsync(id, cancellationToken);
+                                                        return await _taskAgentClient.GetJobMessageAsync(id, cancellationToken);
                                                     }, cancellationToken);
 
             return jobMessage;

src/Runner.Common/AuthMigration.cs

@@ -1,13 +0,0 @@
-using System;
-
-namespace GitHub.Runner.Common
-{
-    public class AuthMigrationEventArgs : EventArgs
-    {
-        public AuthMigrationEventArgs(string trace)
-        {
-            Trace = trace;
-        }
-        public string Trace { get; private set; }
-    }
-}

src/Runner.Common/BrokerServer.cs

@@ -7,7 +7,6 @@ using GitHub.DistributedTask.Pipelines;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
-using GitHub.Services.WebApi;
 using Sdk.RSWebApi.Contracts;
 using Sdk.WebApi.WebApi.RawClient;
 
@@ -18,14 +17,7 @@ namespace GitHub.Runner.Common
     {
         Task ConnectAsync(Uri serverUrl, VssCredentials credentials);
 
-        Task<TaskAgentSession> CreateSessionAsync(TaskAgentSession session, CancellationToken cancellationToken);
-        Task DeleteSessionAsync(CancellationToken cancellationToken);
-
-        Task<TaskAgentMessage> GetRunnerMessageAsync(Guid? sessionId, TaskAgentStatus status, string version, string os, string architecture, bool disableUpdate, CancellationToken token);
-
-        Task UpdateConnectionIfNeeded(Uri serverUri, VssCredentials credentials);
-
-        Task ForceRefreshConnection(VssCredentials credentials);
+        Task<TaskAgentMessage> GetRunnerMessageAsync(CancellationToken token, TaskAgentStatus status, string version, string os, string architecture, bool disableUpdate);
     }
 
     public sealed class BrokerServer : RunnerService, IBrokerServer
@@ -37,7 +29,6 @@ namespace GitHub.Runner.Common
 
         public async Task ConnectAsync(Uri serverUri, VssCredentials credentials)
         {
-            Trace.Entering();
             _brokerUri = serverUri;
 
             _connection = VssUtil.CreateRawConnection(serverUri, credentials);
@@ -53,58 +44,13 @@ namespace GitHub.Runner.Common
             }
         }
 
-        public async Task<TaskAgentSession> CreateSessionAsync(TaskAgentSession session, CancellationToken cancellationToken)
+        public Task<TaskAgentMessage> GetRunnerMessageAsync(CancellationToken cancellationToken, TaskAgentStatus status, string version, string os, string architecture, bool disableUpdate)
         {
             CheckConnection();
-            var jobMessage = await _brokerHttpClient.CreateSessionAsync(session, cancellationToken);
+            var jobMessage = RetryRequest<TaskAgentMessage>(
+                async () => await _brokerHttpClient.GetRunnerMessageAsync(version, status, os, architecture, disableUpdate, cancellationToken), cancellationToken);
 
             return jobMessage;
         }
-
-        public Task<TaskAgentMessage> GetRunnerMessageAsync(Guid? sessionId, TaskAgentStatus status, string version, string os, string architecture, bool disableUpdate, CancellationToken cancellationToken)
-        {
-            CheckConnection();
-            var brokerSession = RetryRequest<TaskAgentMessage>(
-                async () => await _brokerHttpClient.GetRunnerMessageAsync(sessionId, version, status, os, architecture, disableUpdate, cancellationToken), cancellationToken, shouldRetry: ShouldRetryException);
-
-
-            return brokerSession;
-        }
-
-        public async Task DeleteSessionAsync(CancellationToken cancellationToken)
-        {
-            CheckConnection();
-            await _brokerHttpClient.DeleteSessionAsync(cancellationToken);
-        }
-
-        public Task UpdateConnectionIfNeeded(Uri serverUri, VssCredentials credentials)
-        {
-            if (_brokerUri != serverUri || !_hasConnection)
-            {
-                return ConnectAsync(serverUri, credentials);
-            }
-
-            return Task.CompletedTask;
-        }
-
-        public Task ForceRefreshConnection(VssCredentials credentials)
-        {
-            if (!string.IsNullOrEmpty(_brokerUri?.AbsoluteUri))
-            {
-                return ConnectAsync(_brokerUri, credentials);
-            }
-
-            return Task.CompletedTask;
-        }
-
-        public bool ShouldRetryException(Exception ex)
-        {
-            if (ex is AccessDeniedException || ex is RunnerNotFoundException || ex is HostedRunnerDeprovisionedException)
-            {
-                return false;
-            }
-
-            return true;
-        }
     }
 }

src/Runner.Common/ConfigurationStore.cs

@@ -116,15 +116,11 @@ namespace GitHub.Runner.Common
         bool IsConfigured();
         bool IsServiceConfigured();
         bool HasCredentials();
-        bool IsMigratedConfigured();
         CredentialData GetCredentials();
         CredentialData GetMigratedCredentials();
         RunnerSettings GetSettings();
-        RunnerSettings GetMigratedSettings();
         void SaveCredential(CredentialData credential);
-        void SaveMigratedCredential(CredentialData credential);
         void SaveSettings(RunnerSettings settings);
-        void SaveMigratedSettings(RunnerSettings settings);
         void DeleteCredential();
         void DeleteMigratedCredential();
         void DeleteSettings();
@@ -134,7 +130,6 @@ namespace GitHub.Runner.Common
     {
         private string _binPath;
         private string _configFilePath;
-        private string _migratedConfigFilePath;
         private string _credFilePath;
         private string _migratedCredFilePath;
         private string _serviceConfigFilePath;
@@ -142,7 +137,6 @@ namespace GitHub.Runner.Common
         private CredentialData _creds;
         private CredentialData _migratedCreds;
         private RunnerSettings _settings;
-        private RunnerSettings _migratedSettings;
 
         public override void Initialize(IHostContext hostContext)
         {
@@ -160,9 +154,6 @@ namespace GitHub.Runner.Common
             _configFilePath = hostContext.GetConfigFile(WellKnownConfigFile.Runner);
             Trace.Info("ConfigFilePath: {0}", _configFilePath);
 
-            _migratedConfigFilePath = hostContext.GetConfigFile(WellKnownConfigFile.MigratedRunner);
-            Trace.Info("MigratedConfigFilePath: {0}", _migratedConfigFilePath);
-
             _credFilePath = hostContext.GetConfigFile(WellKnownConfigFile.Credentials);
             Trace.Info("CredFilePath: {0}", _credFilePath);
 
@@ -178,7 +169,7 @@ namespace GitHub.Runner.Common
         public bool HasCredentials()
         {
             Trace.Info("HasCredentials()");
-            bool credsStored = new FileInfo(_credFilePath).Exists || new FileInfo(_migratedCredFilePath).Exists;
+            bool credsStored = (new FileInfo(_credFilePath)).Exists || (new FileInfo(_migratedCredFilePath)).Exists;
             Trace.Info("stored {0}", credsStored);
             return credsStored;
         }
@@ -186,7 +177,7 @@ namespace GitHub.Runner.Common
         public bool IsConfigured()
         {
             Trace.Info("IsConfigured()");
-            bool configured = new FileInfo(_configFilePath).Exists || new FileInfo(_migratedConfigFilePath).Exists;
+            bool configured = new FileInfo(_configFilePath).Exists;
             Trace.Info("IsConfigured: {0}", configured);
             return configured;
         }
@@ -194,19 +185,11 @@ namespace GitHub.Runner.Common
         public bool IsServiceConfigured()
         {
             Trace.Info("IsServiceConfigured()");
-            bool serviceConfigured = new FileInfo(_serviceConfigFilePath).Exists;
+            bool serviceConfigured = (new FileInfo(_serviceConfigFilePath)).Exists;
             Trace.Info($"IsServiceConfigured: {serviceConfigured}");
             return serviceConfigured;
         }
 
-        public bool IsMigratedConfigured()
-        {
-            Trace.Info("IsMigratedConfigured()");
-            bool configured = new FileInfo(_migratedConfigFilePath).Exists;
-            Trace.Info("IsMigratedConfigured: {0}", configured);
-            return configured;
-        }
-
         public CredentialData GetCredentials()
         {
             if (_creds == null)
@@ -246,25 +229,6 @@ namespace GitHub.Runner.Common
             return _settings;
         }
 
-        public RunnerSettings GetMigratedSettings()
-        {
-            if (_migratedSettings == null)
-            {
-                RunnerSettings configuredSettings = null;
-                if (File.Exists(_migratedConfigFilePath))
-                {
-                    string json = File.ReadAllText(_migratedConfigFilePath, Encoding.UTF8);
-                    Trace.Info($"Read migrated setting file: {json.Length} chars");
-                    configuredSettings = StringUtil.ConvertFromJson<RunnerSettings>(json);
-                }
-
-                ArgUtil.NotNull(configuredSettings, nameof(configuredSettings));
-                _migratedSettings = configuredSettings;
-            }
-
-            return _migratedSettings;
-        }
-
         public void SaveCredential(CredentialData credential)
         {
             Trace.Info("Saving {0} credential @ {1}", credential.Scheme, _credFilePath);
@@ -280,21 +244,6 @@ namespace GitHub.Runner.Common
             File.SetAttributes(_credFilePath, File.GetAttributes(_credFilePath) | FileAttributes.Hidden);
         }
 
-        public void SaveMigratedCredential(CredentialData credential)
-        {
-            Trace.Info("Saving {0} migrated credential @ {1}", credential.Scheme, _migratedCredFilePath);
-            if (File.Exists(_migratedCredFilePath))
-            {
-                // Delete existing credential file first, since the file is hidden and not able to overwrite.
-                Trace.Info("Delete exist runner migrated credential file.");
-                IOUtil.DeleteFile(_migratedCredFilePath);
-            }
-
-            IOUtil.SaveObject(credential, _migratedCredFilePath);
-            Trace.Info("Migrated Credentials Saved.");
-            File.SetAttributes(_migratedCredFilePath, File.GetAttributes(_migratedCredFilePath) | FileAttributes.Hidden);
-        }
-
         public void SaveSettings(RunnerSettings settings)
         {
             Trace.Info("Saving runner settings.");
@@ -310,21 +259,6 @@ namespace GitHub.Runner.Common
             File.SetAttributes(_configFilePath, File.GetAttributes(_configFilePath) | FileAttributes.Hidden);
         }
 
-        public void SaveMigratedSettings(RunnerSettings settings)
-        {
-            Trace.Info("Saving runner migrated settings");
-            if (File.Exists(_migratedConfigFilePath))
-            {
-                // Delete existing settings file first, since the file is hidden and not able to overwrite.
-                Trace.Info("Delete exist runner migrated settings file.");
-                IOUtil.DeleteFile(_migratedConfigFilePath);
-            }
-
-            IOUtil.SaveObject(settings, _migratedConfigFilePath);
-            Trace.Info("Migrated Settings Saved.");
-            File.SetAttributes(_migratedConfigFilePath, File.GetAttributes(_migratedConfigFilePath) | FileAttributes.Hidden);
-        }
-
         public void DeleteCredential()
         {
             IOUtil.Delete(_credFilePath, default(CancellationToken));
@@ -339,12 +273,6 @@ namespace GitHub.Runner.Common
         public void DeleteSettings()
         {
             IOUtil.Delete(_configFilePath, default(CancellationToken));
-            IOUtil.Delete(_migratedConfigFilePath, default(CancellationToken));
-        }
-
-        public void DeleteMigratedSettings()
-        {
-            IOUtil.Delete(_migratedConfigFilePath, default(CancellationToken));
         }
     }
 }

src/Runner.Common/Constants.cs

@@ -18,7 +18,6 @@ namespace GitHub.Runner.Common
     public enum WellKnownConfigFile
     {
         Runner,
-        MigratedRunner,
         Credentials,
         MigratedCredentials,
         RSACredentials,
@@ -154,37 +153,15 @@ namespace GitHub.Runner.Common
                 public const int RetryableError = 2;
                 public const int RunnerUpdating = 3;
                 public const int RunOnceRunnerUpdating = 4;
-                public const int SessionConflict = 5;
-                // Temporary error code to indicate that the runner configuration has been refreshed
-                // and the runner should be restarted. This is a temporary code and will be removed in the future after
-                // the runner is migrated to runner admin.
-                public const int RunnerConfigurationRefreshed = 6;
             }
 
             public static class Features
             {
                 public static readonly string DiskSpaceWarning = "runner.diskspace.warning";
+                public static readonly string Node16Warning = "DistributedTask.AddWarningToNode16Action";
                 public static readonly string LogTemplateErrorsAsDebugMessages = "DistributedTask.LogTemplateErrorsAsDebugMessages";
                 public static readonly string UseContainerPathForTemplate = "DistributedTask.UseContainerPathForTemplate";
                 public static readonly string AllowRunnerContainerHooks = "DistributedTask.AllowRunnerContainerHooks";
-                public static readonly string AddCheckRunIdToJobContext = "actions_add_check_run_id_to_job_context";
-                public static readonly string DisplayHelpfulActionsDownloadErrors = "actions_display_helpful_actions_download_errors";
-            }
-            
-            // Node version migration related constants
-            public static class NodeMigration
-            {
-                // Node versions
-                public static readonly string Node20 = "node20";
-                public static readonly string Node24 = "node24";
-                
-                // Environment variables for controlling node version selection
-                public static readonly string ForceNode24Variable = "FORCE_JAVASCRIPT_ACTIONS_TO_NODE24";
-                public static readonly string AllowUnsecureNodeVersionVariable = "ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION";
-                
-                // Feature flags for controlling the migration phases
-                public static readonly string UseNode24ByDefaultFlag = "actions.runner.usenode24bydefault";
-                public static readonly string RequireNode24Flag = "actions.runner.requirenode24";
             }
 
             public static readonly string InternalTelemetryIssueDataKey = "_internal_telemetry";
@@ -198,6 +175,11 @@ namespace GitHub.Runner.Common
             public static readonly string UnsupportedStopCommandTokenDisabled = "You cannot use a endToken that is an empty string, the string 'pause-logging', or another workflow command. For more information see: https://docs.github.com/actions/learn-github-actions/workflow-commands-for-github-actions#example-stopping-and-starting-workflow-commands or opt into insecure command execution by setting the `ACTIONS_ALLOW_UNSECURE_STOPCOMMAND_TOKENS` environment variable to `true`.";
             public static readonly string UnsupportedSummarySize = "$GITHUB_STEP_SUMMARY upload aborted, supports content up to a size of {0}k, got {1}k. For more information see: https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-markdown-summary";
             public static readonly string SummaryUploadError = "$GITHUB_STEP_SUMMARY upload aborted, an error occurred when uploading the summary. For more information see: https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-markdown-summary";
+            public static readonly string DetectedNodeAfterEndOfLifeMessage = "Node.js 16 actions are deprecated. Please update the following actions to use Node.js 20: {0}. For more information see: https://github.blog/changelog/2023-09-22-github-actions-transitioning-from-node-16-to-node-20/.";
+            public static readonly string DeprecatedNodeDetectedAfterEndOfLifeActions = "DeprecatedNodeActionsMessageWarnings";
+            public static readonly string DeprecatedNodeVersion = "node16";
+            public static readonly string EnforcedNode12DetectedAfterEndOfLife = "The following actions uses node12 which is deprecated and will be forced to run on node16: {0}. For more info: https://github.blog/changelog/2023-06-13-github-actions-all-actions-will-run-on-node16-instead-of-node12-by-default/";
+            public static readonly string EnforcedNode12DetectedAfterEndOfLifeEnvVariable = "Node16ForceActionsWarnings";
         }
 
         public static class RunnerEvent
@@ -268,13 +250,14 @@ namespace GitHub.Runner.Common
                 public static readonly string RequireJobContainer = "ACTIONS_RUNNER_REQUIRE_JOB_CONTAINER";
                 public static readonly string RunnerDebug = "ACTIONS_RUNNER_DEBUG";
                 public static readonly string StepDebug = "ACTIONS_STEP_DEBUG";
+                public static readonly string AllowActionsUseUnsecureNodeVersion = "ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION";
             }
 
             public static class Agent
             {
                 public static readonly string ToolsDirectory = "agent.ToolsDirectory";
 
-                // Set this env var to "nodeXY" to downgrade the node version for internal functions (e.g hashfiles). This does NOT affect the version of node actions.
+                // Set this env var to "node12" to downgrade the node version for internal functions (e.g hashfiles). This does NOT affect the version of node actions.
                 public static readonly string ForcedInternalNodeVersion = "ACTIONS_RUNNER_FORCED_INTERNAL_NODE_VERSION";
                 public static readonly string ForcedActionsNodeVersion = "ACTIONS_RUNNER_FORCE_ACTIONS_NODE_VERSION";
                 public static readonly string PrintLogToStdout = "ACTIONS_RUNNER_PRINT_LOG_TO_STDOUT";

src/Runner.Common/HostContext.cs

@@ -15,7 +15,6 @@ using System.Threading.Tasks;
 using GitHub.DistributedTask.Logging;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
-using GitHub.Services.WebApi.Jwt;
 
 namespace GitHub.Runner.Common
 {
@@ -37,12 +36,6 @@ namespace GitHub.Runner.Common
         event EventHandler Unloading;
         void ShutdownRunner(ShutdownReason reason);
         void WritePerfCounter(string counter);
-        void LoadDefaultUserAgents();
-
-        bool AllowAuthMigration { get; }
-        void EnableAuthMigration(string trace);
-        void DeferAuthMigration(TimeSpan deferred, string trace);
-        event EventHandler<AuthMigrationEventArgs> AuthMigrationChanged;
     }
 
     public enum StartupType
@@ -74,28 +67,17 @@ namespace GitHub.Runner.Common
         private StartupType _startupType;
         private string _perfFile;
         private RunnerWebProxy _webProxy = new();
-        private string _hostType = string.Empty;
-
-        // disable auth migration by default
-        private readonly ManualResetEventSlim _allowAuthMigration = new ManualResetEventSlim(false);
-        private DateTime _deferredAuthMigrationTime = DateTime.MaxValue;
-        private readonly object _authMigrationLock = new object();
-        private CancellationTokenSource _authMigrationAutoReenableTaskCancellationTokenSource = new();
-        private Task _authMigrationAutoReenableTask;
 
         public event EventHandler Unloading;
-        public event EventHandler<AuthMigrationEventArgs> AuthMigrationChanged;
         public CancellationToken RunnerShutdownToken => _runnerShutdownTokenSource.Token;
         public ShutdownReason RunnerShutdownReason { get; private set; }
         public ISecretMasker SecretMasker => _secretMasker;
         public List<ProductInfoHeaderValue> UserAgents => _userAgents;
         public RunnerWebProxy WebProxy => _webProxy;
-        public bool AllowAuthMigration => _allowAuthMigration.IsSet;
         public HostContext(string hostType, string logFile = null)
         {
             // Validate args.
             ArgUtil.NotNullOrEmpty(hostType, nameof(hostType));
-            _hostType = hostType;
 
             _loadContext = AssemblyLoadContext.GetLoadContext(typeof(HostContext).GetTypeInfo().Assembly);
             _loadContext.Unloading += LoadContext_Unloading;
@@ -214,88 +196,14 @@ namespace GitHub.Runner.Common
                 }
             }
 
-            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY")))
-            {
-                _trace.Warning($"Runner is running under insecure mode: HTTPS server certificate validation has been turned off by GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY environment variable.");
-            }
-
-            LoadDefaultUserAgents();
-        }
-
-        // marked as internal for testing
-        internal async Task AuthMigrationAuthReenableAsync(TimeSpan refreshInterval, CancellationToken token)
-        {
-            try
-            {
-                while (!token.IsCancellationRequested)
-                {
-                    _trace.Verbose($"Auth migration defer timer is set to expire at {_deferredAuthMigrationTime.ToString("O")}. AllowAuthMigration: {_allowAuthMigration.IsSet}.");
-                    await Task.Delay(refreshInterval, token);
-                    if (!_allowAuthMigration.IsSet && DateTime.UtcNow > _deferredAuthMigrationTime)
-                    {
-                        _trace.Info($"Auth migration defer timer expired. Allowing auth migration.");
-                        EnableAuthMigration("Auth migration defer timer expired.");
-                    }
-                }
-            }
-            catch (TaskCanceledException)
-            {
-                // Task was cancelled, exit the loop.
-            }
-            catch (Exception ex)
-            {
-                _trace.Info("Error in auth migration reenable task.");
-                _trace.Error(ex);
-            }
-        }
-
-        public void EnableAuthMigration(string trace)
-        {
-            _allowAuthMigration.Set();
-
-            lock (_authMigrationLock)
-            {
-                if (_authMigrationAutoReenableTask == null)
-                {
-                    var refreshIntervalInMS = 60 * 1000;
-#if DEBUG
-                    // For L0, we will refresh faster
-                    if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("_GITHUB_ACTION_AUTH_MIGRATION_REFRESH_INTERVAL")))
-                    {
-                        refreshIntervalInMS = int.Parse(Environment.GetEnvironmentVariable("_GITHUB_ACTION_AUTH_MIGRATION_REFRESH_INTERVAL"));
-                    }
-#endif
-                    _authMigrationAutoReenableTask = AuthMigrationAuthReenableAsync(TimeSpan.FromMilliseconds(refreshIntervalInMS), _authMigrationAutoReenableTaskCancellationTokenSource.Token);
-                }
-            }
-
-            _trace.Info($"Enable auth migration at {DateTime.UtcNow.ToString("O")}.");
-            AuthMigrationChanged?.Invoke(this, new AuthMigrationEventArgs(trace));
-        }
-
-        public void DeferAuthMigration(TimeSpan deferred, string trace)
-        {
-            _allowAuthMigration.Reset();
-
-            // defer migration for a while
-            lock (_authMigrationLock)
-            {
-                _deferredAuthMigrationTime = DateTime.UtcNow.Add(deferred);
-            }
-
-            _trace.Info($"Disabled auth migration until {_deferredAuthMigrationTime.ToString("O")}.");
-            AuthMigrationChanged?.Invoke(this, new AuthMigrationEventArgs(trace));
-        }
-
-        public void LoadDefaultUserAgents()
-        {
             if (string.IsNullOrEmpty(WebProxy.HttpProxyAddress) && string.IsNullOrEmpty(WebProxy.HttpsProxyAddress))
             {
                 _trace.Info($"No proxy settings were found based on environmental variables (http_proxy/https_proxy/HTTP_PROXY/HTTPS_PROXY)");
             }
-            else
+
+            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY")))
             {
-                _userAgents.Add(new ProductInfoHeaderValue("HttpProxyConfigured", bool.TrueString));
+                _trace.Warning($"Runner is running under insecure mode: HTTPS server certificate validation has been turned off by GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY environment variable.");
             }
 
             var credFile = GetConfigFile(WellKnownConfigFile.Credentials);
@@ -307,36 +215,6 @@ namespace GitHub.Runner.Common
                 {
                     _userAgents.Add(new ProductInfoHeaderValue("ClientId", clientId));
                 }
-
-                // for Hosted runner, we can pull orchestrationId from JWT claims of the runner listening token.
-                if (credData != null &&
-                    credData.Scheme == Constants.Configuration.OAuthAccessToken &&
-                    credData.Data.TryGetValue(Constants.Runner.CommandLine.Args.Token, out var accessToken) &&
-                    !string.IsNullOrEmpty(accessToken))
-                {
-                    try
-                    {
-                        var jwt = JsonWebToken.Create(accessToken);
-                        var claims = jwt.ExtractClaims();
-                        var orchestrationId = claims.FirstOrDefault(x => string.Equals(x.Type, "orch_id", StringComparison.OrdinalIgnoreCase))?.Value;
-                        if (string.IsNullOrEmpty(orchestrationId))
-                        {
-                            // fallback to orchid for C# actions-service
-                            orchestrationId = claims.FirstOrDefault(x => string.Equals(x.Type, "orchid", StringComparison.OrdinalIgnoreCase))?.Value;
-                        }
-
-                        if (!string.IsNullOrEmpty(orchestrationId))
-                        {
-                            _trace.Info($"Pull OrchestrationId {orchestrationId} from runner JWT claims");
-                            _userAgents.Insert(0, new ProductInfoHeaderValue("OrchestrationId", orchestrationId));
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        _trace.Error("Fail to extract OrchestrationId from runner JWT claims");
-                        _trace.Error(ex);
-                    }
-                }
             }
 
             var runnerFile = GetConfigFile(WellKnownConfigFile.Runner);
@@ -362,11 +240,6 @@ namespace GitHub.Runner.Common
                 _trace.Info($"Adding extra user agent '{extraUserAgentHeader}' to all HTTP requests.");
                 _userAgents.Add(extraUserAgentHeader);
             }
-
-            var currentProcess = Process.GetCurrentProcess();
-            _userAgents.Add(new ProductInfoHeaderValue("Pid", currentProcess.Id.ToString()));
-            _userAgents.Add(new ProductInfoHeaderValue("CreationTime", Uri.EscapeDataString(DateTime.UtcNow.ToString("O"))));
-            _userAgents.Add(new ProductInfoHeaderValue($"({_hostType})"));
         }
 
         public string GetDirectory(WellKnownDirectory directory)
@@ -453,12 +326,6 @@ namespace GitHub.Runner.Common
                         ".runner");
                     break;
 
-                case WellKnownConfigFile.MigratedRunner:
-                    path = Path.Combine(
-                        GetDirectory(WellKnownDirectory.Root),
-                        ".runner_migrated");
-                    break;
-
                 case WellKnownConfigFile.Credentials:
                     path = Path.Combine(
                         GetDirectory(WellKnownDirectory.Root),
@@ -659,18 +526,6 @@ namespace GitHub.Runner.Common
                     _loadContext.Unloading -= LoadContext_Unloading;
                     _loadContext = null;
                 }
-
-                if (_authMigrationAutoReenableTask != null)
-                {
-                    _authMigrationAutoReenableTaskCancellationTokenSource?.Cancel();
-                }
-
-                if (_authMigrationAutoReenableTaskCancellationTokenSource != null)
-                {
-                    _authMigrationAutoReenableTaskCancellationTokenSource?.Dispose();
-                    _authMigrationAutoReenableTaskCancellationTokenSource = null;
-                }
-
                 _httpTraceSubscription?.Dispose();
                 _diagListenerSubscription?.Dispose();
                 _traceManager?.Dispose();
@@ -757,7 +612,7 @@ namespace GitHub.Runner.Common
                     payload[0] = Enum.Parse(typeof(GitHub.Services.Common.VssCredentialsType), ((int)payload[0]).ToString());
                 }
 
-                if (payload.Length > 0 && !string.IsNullOrEmpty(eventData.Message))
+                if (payload.Length > 0)
                 {
                     message = String.Format(eventData.Message.Replace("%n", Environment.NewLine), payload);
                 }

src/Runner.Common/JobServer.cs

@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Net.Security;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
@@ -180,10 +179,6 @@ namespace GitHub.Runner.Common
                     userAgentValues.AddRange(UserAgentUtility.GetDefaultRestUserAgent());
                     userAgentValues.AddRange(HostContext.UserAgents);
                     this._websocketClient.Options.SetRequestHeader("User-Agent", string.Join(" ", userAgentValues.Select(x => x.ToString())));
-                    if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY")))
-                    {
-                        this._websocketClient.Options.RemoteCertificateValidationCallback = (_, _, _, _) => true;
-                    }
 
                     this._websocketConnectTask = ConnectWebSocketClient(feedStreamUrl, delay);
                 }

src/Runner.Common/JobServerQueue.cs

@@ -19,7 +19,7 @@ namespace GitHub.Runner.Common
         TaskCompletionSource<int> JobRecordUpdated { get; }
         event EventHandler<ThrottlingEventArgs> JobServerQueueThrottling;
         Task ShutdownAsync();
-        void Start(Pipelines.AgentJobRequestMessage jobRequest, bool resultsServiceOnly = false);
+        void Start(Pipelines.AgentJobRequestMessage jobRequest, bool resultsServiceOnly = false, bool enableTelemetry = false);
         void QueueWebConsoleLine(Guid stepRecordId, string line, long? lineNumber = null);
         void QueueFileUpload(Guid timelineId, Guid timelineRecordId, string type, string name, string path, bool deleteSource);
         void QueueResultsUpload(Guid timelineRecordId, string name, string path, string type, bool deleteSource, bool finalize, bool firstBlock, long totalLines);
@@ -74,7 +74,6 @@ namespace GitHub.Runner.Common
         private readonly List<JobTelemetry> _jobTelemetries = new();
         private bool _queueInProcess = false;
         private bool _resultsServiceOnly = false;
-        private int _resultsServiceExceptionsCount = 0;
         private Stopwatch _resultsUploadTimer = new();
         private Stopwatch _actionsUploadTimer = new();
 
@@ -105,10 +104,11 @@ namespace GitHub.Runner.Common
             _resultsServer = hostContext.GetService<IResultsServer>();
         }
 
-        public void Start(Pipelines.AgentJobRequestMessage jobRequest, bool resultsServiceOnly = false)
+        public void Start(Pipelines.AgentJobRequestMessage jobRequest, bool resultsServiceOnly = false, bool enableTelemetry = false)
         {
             Trace.Entering();
             _resultsServiceOnly = resultsServiceOnly;
+            _enableTelemetry = enableTelemetry;
 
             var serviceEndPoint = jobRequest.Resources.Endpoints.Single(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
 
@@ -134,15 +134,9 @@ namespace GitHub.Runner.Common
                 {
                     liveConsoleFeedUrl = feedStreamUrl;
                 }
-                jobRequest.Variables.TryGetValue("system.github.results_upload_with_sdk", out VariableValue resultsUseSdkVariable);
-                _resultsServer.InitializeResultsClient(new Uri(resultsReceiverEndpoint), liveConsoleFeedUrl, accessToken, StringUtil.ConvertToBoolean(resultsUseSdkVariable?.Value));
-                _resultsClientInitiated = true;
-            }
 
-            // Enable telemetry if we have both results service and actions service
-            if (_resultsClientInitiated && !_resultsServiceOnly)
-            {
-                _enableTelemetry = true;
+                _resultsServer.InitializeResultsClient(new Uri(resultsReceiverEndpoint), liveConsoleFeedUrl, accessToken);
+                _resultsClientInitiated = true;
             }
 
             if (_queueInProcess)
@@ -557,10 +551,6 @@ namespace GitHub.Runner.Common
                             {
                                 await UploadSummaryFile(file);
                             }
-                            if (string.Equals(file.Type, CoreAttachmentType.ResultsDiagnosticLog, StringComparison.OrdinalIgnoreCase))
-                            {
-                                await UploadResultsDiagnosticLogsFile(file);
-                            }
                             else if (String.Equals(file.Type, CoreAttachmentType.ResultsLog, StringComparison.OrdinalIgnoreCase))
                             {
                                 if (file.RecordId != _jobTimelineRecordId)
@@ -580,9 +570,9 @@ namespace GitHub.Runner.Common
                             Trace.Info("Catch exception during file upload to results, keep going since the process is best effort.");
                             Trace.Error(ex);
                             errorCount++;
-                            _resultsServiceExceptionsCount++;
+
                             // If we hit any exceptions uploading to Results, let's skip any additional uploads to Results unless Results is serving logs
-                            if (!_resultsServiceOnly && _resultsServiceExceptionsCount > 3)
+                            if (!_resultsServiceOnly)
                             {
                                 _resultsClientInitiated = false;
                                 SendResultsTelemetry(ex);
@@ -613,7 +603,7 @@ namespace GitHub.Runner.Common
 
         private void SendResultsTelemetry(Exception ex)
         {
-            var issue = new Issue() { Type = IssueType.Warning, Message = $"Caught exception with results. {HostContext.SecretMasker.MaskSecrets(ex.Message)}" };
+            var issue = new Issue() { Type = IssueType.Warning, Message = $"Caught exception with results. {ex.Message}" };
             issue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.ResultsUploadFailure;
 
             var telemetryRecord = new TimelineRecord()
@@ -709,9 +699,7 @@ namespace GitHub.Runner.Common
                             {
                                 Trace.Info("Catch exception during update steps, skip update Results.");
                                 Trace.Error(e);
-                                _resultsServiceExceptionsCount++;
-                                // If we hit any exceptions uploading to Results, let's skip any additional uploads to Results unless Results is serving logs
-                                if (!_resultsServiceOnly && _resultsServiceExceptionsCount > 3)
+                                if (!_resultsServiceOnly)
                                 {
                                     _resultsClientInitiated = false;
                                     SendResultsTelemetry(e);
@@ -934,17 +922,6 @@ namespace GitHub.Runner.Common
             await UploadResultsFile(file, summaryHandler);
         }
 
-        private async Task UploadResultsDiagnosticLogsFile(ResultsUploadFileInfo file)
-        {
-            Trace.Info($"Starting to upload diagnostic logs file to results service {file.Name}, {file.Path}");
-            ResultsFileUploadHandler diagnosticLogsHandler = async (file) =>
-            {
-                await _resultsServer.CreateResultsDiagnosticLogsAsync(file.PlanId, file.JobId, file.Path, CancellationToken.None);
-            };
-
-            await UploadResultsFile(file, diagnosticLogsHandler);
-        }
-
         private async Task UploadResultsStepLogFile(ResultsUploadFileInfo file)
         {
             Trace.Info($"Starting upload of step log file to results service {file.Name}, {file.Path}");

src/Runner.Common/LaunchServer.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Net.Http;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Sdk;
-using GitHub.Services.Common;
 using GitHub.Services.Launch.Client;
+using GitHub.Services.WebApi;
 
 namespace GitHub.Runner.Common
 {
@@ -15,7 +14,7 @@ namespace GitHub.Runner.Common
     {
         void InitializeLaunchClient(Uri uri, string token);
 
-        Task<ActionDownloadInfoCollection> ResolveActionsDownloadInfoAsync(Guid planId, Guid jobId, ActionReferenceList actionReferenceList, CancellationToken cancellationToken, bool displayHelpfulActionsDownloadErrors);
+        Task<ActionDownloadInfoCollection> ResolveActionsDownloadInfoAsync(Guid planId, Guid jobId, ActionReferenceList actionReferenceList, CancellationToken cancellationToken);
     }
 
     public sealed class LaunchServer : RunnerService, ILaunchServer
@@ -24,34 +23,17 @@ namespace GitHub.Runner.Common
 
         public void InitializeLaunchClient(Uri uri, string token)
         {
-            // Using default 100 timeout
-            RawClientHttpRequestSettings settings = VssUtil.GetHttpRequestSettings(null);
-
-            // Create retry handler
-            IEnumerable<DelegatingHandler> delegatingHandlers = new List<DelegatingHandler>();
-            if (settings.MaxRetryRequest > 0)
-            {
-                delegatingHandlers = new DelegatingHandler[] { new VssHttpRetryMessageHandler(settings.MaxRetryRequest) };
-            }
-
-            // Setup RawHttpMessageHandler without credentials
-            var httpMessageHandler = new RawHttpMessageHandler(new NoOpCredentials(null), settings);
-            var pipeline = HttpClientFactory.CreatePipeline(httpMessageHandler, delegatingHandlers);
-
-            this._launchClient = new LaunchHttpClient(uri, pipeline, token, disposeHandler: true);
+            var httpMessageHandler = HostContext.CreateHttpClientHandler();
+            this._launchClient = new LaunchHttpClient(uri, httpMessageHandler, token, disposeHandler: true);
         }
 
         public Task<ActionDownloadInfoCollection> ResolveActionsDownloadInfoAsync(Guid planId, Guid jobId, ActionReferenceList actionReferenceList,
-            CancellationToken cancellationToken, bool displayHelpfulActionsDownloadErrors)
+            CancellationToken cancellationToken)
         {
             if (_launchClient != null)
             {
-                if (!displayHelpfulActionsDownloadErrors)
-                {
-                    return _launchClient.GetResolveActionsDownloadInfoAsync(planId, jobId, actionReferenceList,
-                        cancellationToken: cancellationToken);
-                }
-                return _launchClient.GetResolveActionsDownloadInfoAsyncV2(planId, jobId, actionReferenceList, cancellationToken);
+                return _launchClient.GetResolveActionsDownloadInfoAsync(planId, jobId, actionReferenceList,
+                    cancellationToken: cancellationToken);
             }
 
             throw new InvalidOperationException("Launch client is not initialized.");

src/Runner.Common/ResultsServer.cs

@@ -19,7 +19,7 @@ namespace GitHub.Runner.Common
     [ServiceLocator(Default = typeof(ResultServer))]
     public interface IResultsServer : IRunnerService, IAsyncDisposable
     {
-        void InitializeResultsClient(Uri uri, string liveConsoleFeedUrl, string token, bool useSdk);
+        void InitializeResultsClient(Uri uri, string liveConsoleFeedUrl, string token);
 
         Task<bool> AppendLiveConsoleFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long? startLine, CancellationToken cancellationToken);
 
@@ -35,8 +35,6 @@ namespace GitHub.Runner.Common
 
         Task UpdateResultsWorkflowStepsAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId,
             IEnumerable<TimelineRecord> records, CancellationToken cancellationToken);
-
-        Task CreateResultsDiagnosticLogsAsync(string planId, string jobId, string file, CancellationToken cancellationToken);
     }
 
     public sealed class ResultServer : RunnerService, IResultsServer
@@ -53,9 +51,9 @@ namespace GitHub.Runner.Common
         private String _liveConsoleFeedUrl;
         private string _token;
 
-        public void InitializeResultsClient(Uri uri, string liveConsoleFeedUrl, string token, bool useSdk)
+        public void InitializeResultsClient(Uri uri, string liveConsoleFeedUrl, string token)
         {
-            this._resultsClient = CreateHttpClient(uri, token, useSdk);
+            this._resultsClient = CreateHttpClient(uri, token);
 
             _token = token;
             if (!string.IsNullOrEmpty(liveConsoleFeedUrl))
@@ -65,7 +63,7 @@ namespace GitHub.Runner.Common
             }
         }
 
-        public ResultsHttpClient CreateHttpClient(Uri uri, string token, bool useSdk)
+        public ResultsHttpClient CreateHttpClient(Uri uri, string token)
         {
             // Using default 100 timeout
             RawClientHttpRequestSettings settings = VssUtil.GetHttpRequestSettings(null);
@@ -82,7 +80,7 @@ namespace GitHub.Runner.Common
 
             var pipeline = HttpClientFactory.CreatePipeline(httpMessageHandler, delegatingHandlers);
 
-            return new ResultsHttpClient(uri, pipeline, token, disposeHandler: true, useSdk: useSdk);
+            return new ResultsHttpClient(uri, pipeline, token, disposeHandler: true);
         }
 
         public Task CreateResultsStepSummaryAsync(string planId, string jobId, Guid stepId, string file,
@@ -143,18 +141,6 @@ namespace GitHub.Runner.Common
             throw new InvalidOperationException("Results client is not initialized.");
         }
 
-        public Task CreateResultsDiagnosticLogsAsync(string planId, string jobId, string file,
-            CancellationToken cancellationToken)
-        {
-            if (_resultsClient != null)
-            {
-                return _resultsClient.UploadResultsDiagnosticLogsAsync(planId, jobId, file,
-                    cancellationToken: cancellationToken);
-            }
-
-            throw new InvalidOperationException("Results client is not initialized.");
-        }
-
         public ValueTask DisposeAsync()
         {
             CloseWebSocket(WebSocketCloseStatus.NormalClosure, CancellationToken.None);

src/Runner.Common/RunServer.cs

@@ -5,7 +5,6 @@ using System.Threading.Tasks;
 using GitHub.Actions.RunService.WebApi;
 using GitHub.DistributedTask.Pipelines;
 using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using Sdk.RSWebApi.Contracts;
@@ -18,7 +17,7 @@ namespace GitHub.Runner.Common
     {
         Task ConnectAsync(Uri serverUrl, VssCredentials credentials);
 
-        Task<AgentJobRequestMessage> GetJobMessageAsync(string id, string billingOwnerId, CancellationToken token);
+        Task<AgentJobRequestMessage> GetJobMessageAsync(string id, CancellationToken token);
 
         Task CompleteJobAsync(
             Guid planId,
@@ -28,8 +27,6 @@ namespace GitHub.Runner.Common
             IList<StepResult> stepResults,
             IList<Annotation> jobAnnotations,
             string environmentUrl,
-            IList<Telemetry> telemetry,
-            string billingOwnerId,
             CancellationToken token);
 
         Task<RenewJobResponse> RenewJobAsync(Guid planId, Guid jobId, CancellationToken token);
@@ -59,15 +56,12 @@ namespace GitHub.Runner.Common
             }
         }
 
-        public Task<AgentJobRequestMessage> GetJobMessageAsync(string id, string billingOwnerId, CancellationToken cancellationToken)
+        public Task<AgentJobRequestMessage> GetJobMessageAsync(string id, CancellationToken cancellationToken)
         {
             CheckConnection();
             return RetryRequest<AgentJobRequestMessage>(
-                async () => await _runServiceHttpClient.GetJobMessageAsync(requestUri, id, VarUtil.OS, billingOwnerId, cancellationToken), cancellationToken,
-                shouldRetry: ex =>
-                    ex is not TaskOrchestrationJobNotFoundException &&          // HTTP status 404
-                    ex is not TaskOrchestrationJobAlreadyAcquiredException &&   // HTTP status 409
-                    ex is not TaskOrchestrationJobUnprocessableException);      // HTTP status 422
+                async () => await _runServiceHttpClient.GetJobMessageAsync(requestUri, id, cancellationToken), cancellationToken,
+                shouldRetry: ex => ex is not TaskOrchestrationJobAlreadyAcquiredException);
         }
 
         public Task CompleteJobAsync(
@@ -78,25 +72,18 @@ namespace GitHub.Runner.Common
             IList<StepResult> stepResults,
             IList<Annotation> jobAnnotations,
             string environmentUrl,
-            IList<Telemetry> telemetry,
-            string billingOwnerId,
             CancellationToken cancellationToken)
         {
             CheckConnection();
             return RetryRequest(
-                async () => await _runServiceHttpClient.CompleteJobAsync(requestUri, planId, jobId, result, outputs, stepResults, jobAnnotations, environmentUrl, telemetry, billingOwnerId, cancellationToken), cancellationToken,
-                shouldRetry: ex =>
-                    ex is not VssUnauthorizedException &&               // HTTP status 401
-                    ex is not TaskOrchestrationJobNotFoundException);   // HTTP status 404
+                async () => await _runServiceHttpClient.CompleteJobAsync(requestUri, planId, jobId, result, outputs, stepResults, jobAnnotations, environmentUrl, cancellationToken), cancellationToken);
         }
 
         public Task<RenewJobResponse> RenewJobAsync(Guid planId, Guid jobId, CancellationToken cancellationToken)
         {
             CheckConnection();
             return RetryRequest<RenewJobResponse>(
-                async () => await _runServiceHttpClient.RenewJobAsync(requestUri, planId, jobId, cancellationToken), cancellationToken,
-                shouldRetry: ex =>
-                    ex is not TaskOrchestrationJobNotFoundException);   // HTTP status 404
+                async () => await _runServiceHttpClient.RenewJobAsync(requestUri, planId, jobId, cancellationToken), cancellationToken);
         }
     }
 }

src/Runner.Common/Runner.Common.csproj

@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Library</OutputType>
     <RuntimeIdentifiers>win-x64;win-x86;linux-x64;linux-arm64;linux-arm;osx-x64;osx-arm64;win-arm64</RuntimeIdentifiers>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
-    <NoWarn>NU1701;NU1603;SYSLIB0050;SYSLIB0051</NoWarn>
+    <NoWarn>NU1701;NU1603</NoWarn>
     <Version>$(Version)</Version>
   </PropertyGroup>
 
@@ -15,11 +15,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.4.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="8.0.0" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="8.0.0" />
-    <PackageReference Include="System.Threading.Channels" Version="8.0.0" />
+    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="4.4.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.4.0" />
+    <PackageReference Include="System.Threading.Channels" Version="4.4.0" />
   </ItemGroup>
 
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

src/Runner.Common/RunnerDotcomServer.cs

@@ -19,7 +19,6 @@ namespace GitHub.Runner.Common
 
         Task<DistributedTask.WebApi.Runner> AddRunnerAsync(int runnerGroupId, TaskAgent agent, string githubUrl, string githubToken, string publicKey);
         Task<DistributedTask.WebApi.Runner> ReplaceRunnerAsync(int runnerGroupId, TaskAgent agent, string githubUrl, string githubToken, string publicKey);
-        Task DeleteRunnerAsync(string githubUrl, string githubToken, ulong runnerId);
         Task<List<TaskAgentPool>> GetRunnerGroupsAsync(string githubUrl, string githubToken);
     }
 
@@ -44,15 +43,89 @@ namespace GitHub.Runner.Common
 
         public async Task<List<TaskAgent>> GetRunnerByNameAsync(string githubUrl, string githubToken, string agentName)
         {
-            var githubApiUrl = $"{GetEntityUrl(githubUrl)}/runners?name={Uri.EscapeDataString(agentName)}";
+            var githubApiUrl = "";
+            var gitHubUrlBuilder = new UriBuilder(githubUrl);
+            var path = gitHubUrlBuilder.Path.Split('/', '\\', StringSplitOptions.RemoveEmptyEntries);
+            if (path.Length == 1)
+            {
+                // org runner
+                if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/orgs/{path[0]}/actions/runners?name={Uri.EscapeDataString(agentName)}";
+                }
+                else
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/orgs/{path[0]}/actions/runners?name={Uri.EscapeDataString(agentName)}";
+                }
+            }
+            else if (path.Length == 2)
+            {
+                // repo or enterprise runner.
+                if (!string.Equals(path[0], "enterprises", StringComparison.OrdinalIgnoreCase))
+                {
+                    return null;
+                }
+
+                if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/{path[0]}/{path[1]}/actions/runners?name={Uri.EscapeDataString(agentName)}";
+                }
+                else
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/{path[0]}/{path[1]}/actions/runners?name={Uri.EscapeDataString(agentName)}";
+                }
+            }
+            else
+            {
+                throw new ArgumentException($"'{githubUrl}' should point to an org or enterprise.");
+            }
+
             var runnersList = await RetryRequest<ListRunnersResponse>(githubApiUrl, githubToken, RequestType.Get, 3, "Failed to get agents pools");
+
             return runnersList.ToTaskAgents();
         }
 
         public async Task<List<TaskAgentPool>> GetRunnerGroupsAsync(string githubUrl, string githubToken)
         {
-            var githubApiUrl = $"{GetEntityUrl(githubUrl)}/runner-groups";
+            var githubApiUrl = "";
+            var gitHubUrlBuilder = new UriBuilder(githubUrl);
+            var path = gitHubUrlBuilder.Path.Split('/', '\\', StringSplitOptions.RemoveEmptyEntries);
+            if (path.Length == 1)
+            {
+                // org runner
+                if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/orgs/{path[0]}/actions/runner-groups";
+                }
+                else
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/orgs/{path[0]}/actions/runner-groups";
+                }
+            }
+            else if (path.Length == 2)
+            {
+                // repo or enterprise runner.
+                if (!string.Equals(path[0], "enterprises", StringComparison.OrdinalIgnoreCase))
+                {
+                    return null;
+                }
+
+                if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/{path[0]}/{path[1]}/actions/runner-groups";
+                }
+                else
+                {
+                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/{path[0]}/{path[1]}/actions/runner-groups";
+                }
+            }
+            else
+            {
+                throw new ArgumentException($"'{githubUrl}' should point to an org or enterprise.");
+            }
+
             var agentPools = await RetryRequest<RunnerGroupList>(githubApiUrl, githubToken, RequestType.Get, 3, "Failed to get agents pools");
+
             return agentPools?.ToAgentPoolList();
         }
 
@@ -103,12 +176,6 @@ namespace GitHub.Runner.Common
             return await RetryRequest<DistributedTask.WebApi.Runner>(githubApiUrl, githubToken, RequestType.Post, 3, "Failed to add agent", body);
         }
 
-        public async Task DeleteRunnerAsync(string githubUrl, string githubToken, ulong runnerId)
-        {
-            var githubApiUrl = $"{GetEntityUrl(githubUrl)}/runners/{runnerId}";
-            await RetryRequest<DistributedTask.WebApi.Runner>(githubApiUrl, githubToken, RequestType.Delete, 3, "Failed to delete agent");
-        }
-
         private async Task<T> RetryRequest<T>(string githubApiUrl, string githubToken, RequestType requestType, int maxRetryAttemptsCount = 5, string errorMessage = null, StringContent body = null)
         {
             int retry = 0;
@@ -125,22 +192,13 @@ namespace GitHub.Runner.Common
                     try
                     {
                         HttpResponseMessage response = null;
-                        switch (requestType)
+                        if (requestType == RequestType.Get)
                         {
-                            case RequestType.Get:
-                                response = await httpClient.GetAsync(githubApiUrl);
-                                break;
-                            case RequestType.Post:
-                                response = await httpClient.PostAsync(githubApiUrl, body);
-                                break;
-                            case RequestType.Patch:
-                                response = await httpClient.PatchAsync(githubApiUrl, body);
-                                break;
-                            case RequestType.Delete:
-                                response = await httpClient.DeleteAsync(githubApiUrl);
-                                break;
-                            default:
-                                throw new ArgumentOutOfRangeException(nameof(requestType), requestType, null);
+                            response = await httpClient.GetAsync(githubApiUrl);
+                        }
+                        else
+                        {
+                            response = await httpClient.PostAsync(githubApiUrl, body);
                         }
 
                         if (response != null)
@@ -175,61 +233,5 @@ namespace GitHub.Runner.Common
                 await Task.Delay(backOff);
             }
         }
-
-        private string GetEntityUrl(string githubUrl)
-        {
-            var githubApiUrl = "";
-            var gitHubUrlBuilder = new UriBuilder(githubUrl);
-            var path = gitHubUrlBuilder.Path.Split('/', '\\', StringSplitOptions.RemoveEmptyEntries);
-            var isOrgRunner = path.Length == 1;
-            var isRepoOrEnterpriseRunner = path.Length == 2;
-            var isRepoRunner = isRepoOrEnterpriseRunner && !string.Equals(path[0], "enterprises", StringComparison.OrdinalIgnoreCase);
-
-            if (isOrgRunner)
-            {
-                // org runner
-                if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
-                {
-                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/orgs/{path[0]}/actions";
-                }
-                else
-                {
-                    githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/orgs/{path[0]}/actions";
-                }
-            }
-            else if (isRepoOrEnterpriseRunner)
-            {
-                // Repository Runner
-                if (isRepoRunner)
-                {
-                    if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
-                    {
-                        githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/repos/{path[0]}/{path[1]}/actions";
-                    }
-                    else
-                    {
-                        githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/repos/{path[0]}/{path[1]}/actions";
-                    }
-                }
-                else
-                {
-                    // Enterprise Runner
-                    if (UrlUtil.IsHostedServer(gitHubUrlBuilder))
-                    {
-                        githubApiUrl = $"{gitHubUrlBuilder.Scheme}://api.{gitHubUrlBuilder.Host}/{path[0]}/{path[1]}/actions";
-                    }
-                    else
-                    {
-                        githubApiUrl = $"{gitHubUrlBuilder.Scheme}://{gitHubUrlBuilder.Host}/api/v3/{path[0]}/{path[1]}/actions";
-                    }
-                }
-            }
-            else
-            {
-                throw new ArgumentException($"'{githubUrl}' should point to an org or enterprise.");
-            }
-
-            return githubApiUrl;
-        }
     }
 }

src/Runner.Common/RunnerServer.cs

@@ -1,11 +1,11 @@
-using System;
+using GitHub.DistributedTask.WebApi;
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Sdk;
-using GitHub.Services.Common;
 using GitHub.Services.WebApi;
+using GitHub.Services.Common;
+using GitHub.Runner.Sdk;
 
 namespace GitHub.Runner.Common
 {
@@ -50,10 +50,7 @@ namespace GitHub.Runner.Common
         Task<PackageMetadata> GetPackageAsync(string packageType, string platform, string version, bool includeToken, CancellationToken cancellationToken);
 
         // agent update
-        Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, ulong agentId, string currentState, string trace, CancellationToken cancellationToken = default);
-
-        // runner config refresh
-        Task<string> RefreshRunnerConfigAsync(int agentId, string configType, string encodedRunnerConfig, CancellationToken cancellationToken);
+        Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, ulong agentId, string currentState, string trace);
     }
 
     public sealed class RunnerServer : RunnerService, IRunnerServer
@@ -318,17 +315,10 @@ namespace GitHub.Runner.Common
             return _genericTaskAgentClient.GetPackageAsync(packageType, platform, version, includeToken, cancellationToken: cancellationToken);
         }
 
-        public Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, ulong agentId, string currentState, string trace, CancellationToken cancellationToken = default)
+        public Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, ulong agentId, string currentState, string trace)
         {
             CheckConnection(RunnerConnectionType.Generic);
-            return _genericTaskAgentClient.UpdateAgentUpdateStateAsync(agentPoolId, agentId, currentState, trace, cancellationToken: cancellationToken);
-        }
-
-        // runner config refresh
-        public Task<string> RefreshRunnerConfigAsync(int agentId, string configType, string encodedRunnerConfig, CancellationToken cancellationToken)
-        {
-            CheckConnection(RunnerConnectionType.Generic);
-            return _genericTaskAgentClient.RefreshRunnerConfigAsync(agentId, configType, encodedRunnerConfig, cancellationToken: cancellationToken);
+            return _genericTaskAgentClient.UpdateAgentUpdateStateAsync(agentPoolId, agentId, currentState, trace);
         }
     }
 }

src/Runner.Common/RunnerService.cs

@@ -70,8 +70,7 @@ namespace GitHub.Runner.Common
 
         protected async Task RetryRequest(Func<Task> func,
             CancellationToken cancellationToken,
-            int maxRetryAttemptsCount = 5,
-            Func<Exception, bool> shouldRetry = null
+            int maxRetryAttemptsCount = 5
         )
         {
             async Task<Unit> wrappedFunc()
@@ -79,7 +78,7 @@ namespace GitHub.Runner.Common
                 await func();
                 return Unit.Value;
             }
-            await RetryRequest<Unit>(wrappedFunc, cancellationToken, maxRetryAttemptsCount, shouldRetry);
+            await RetryRequest<Unit>(wrappedFunc, cancellationToken, maxRetryAttemptsCount);
         }
 
         protected async Task<T> RetryRequest<T>(Func<Task<T>> func,

src/Runner.Common/TraceSetting.cs

@@ -19,6 +19,13 @@ namespace GitHub.Runner.Common
             {
                 DefaultTraceLevel = TraceLevel.Verbose;
             }
+            else if (int.TryParse(Environment.GetEnvironmentVariable("ACTIONS_RUNNER_TRACE_LEVEL"), out var traceLevel))
+            {
+                // force user's TraceLevel to comply with runner TraceLevel enums
+                traceLevel = Math.Clamp(traceLevel, 0, 5);
+
+                DefaultTraceLevel = (TraceLevel)traceLevel;
+            }
         }
 
         [DataMember(EmitDefaultValue = false)]

src/Runner.Common/Util/NodeUtil.cs

@@ -1,35 +1,12 @@
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using GitHub.Runner.Sdk;
 
 namespace GitHub.Runner.Common.Util
 {
     public static class NodeUtil
     {
-        /// <summary>
-        /// Represents details about an environment variable, including its value and source
-        /// </summary>
-        private class EnvironmentVariableInfo
-        {
-            /// <summary>
-            /// Gets or sets whether the value evaluates to true
-            /// </summary>
-            public bool IsTrue { get; set; }
-
-            /// <summary>
-            /// Gets or sets whether the value came from the workflow environment
-            /// </summary>
-            public bool FromWorkflow { get; set; }
-
-            /// <summary>
-            /// Gets or sets whether the value came from the system environment
-            /// </summary>
-            public bool FromSystem { get; set; }
-        }
-
-        private const string _defaultNodeVersion = "node20";
-        public static readonly ReadOnlyCollection<string> BuiltInNodeVersions = new(new[] { "node20" });
+        private const string _defaultNodeVersion = "node16";
+        public static readonly ReadOnlyCollection<string> BuiltInNodeVersions = new(new[] { "node16", "node20" });
         public static string GetInternalNodeVersion()
         {
             var forcedInternalNodeVersion = Environment.GetEnvironmentVariable(Constants.Variables.Agent.ForcedInternalNodeVersion);
@@ -41,122 +18,5 @@ namespace GitHub.Runner.Common.Util
             }
             return _defaultNodeVersion;
         }
-        /// <summary>
-        /// Determines the appropriate Node version for Actions to use
-        /// </summary>
-        /// <param name="workflowEnvironment">Optional dictionary containing workflow-level environment variables</param>
-        /// <param name="useNode24ByDefault">Feature flag indicating if Node 24 should be the default</param>
-        /// <param name="requireNode24">Feature flag indicating if Node 24 is required</param>
-        /// <returns>The Node version to use (node20 or node24) and warning message if both env vars are set</returns>
-        public static (string nodeVersion, string warningMessage) DetermineActionsNodeVersion(
-            IDictionary<string, string> workflowEnvironment = null,
-            bool useNode24ByDefault = false,
-            bool requireNode24 = false)
-        {
-            // Phase 3: Always use Node 24 regardless of environment variables
-            if (requireNode24)
-            {
-                return (Constants.Runner.NodeMigration.Node24, null);
-            }
-            
-            // Get environment variable details with source information
-            var forceNode24Details = GetEnvironmentVariableDetails(
-                Constants.Runner.NodeMigration.ForceNode24Variable, workflowEnvironment);
-
-            var allowUnsecureNodeDetails = GetEnvironmentVariableDetails(
-                Constants.Runner.NodeMigration.AllowUnsecureNodeVersionVariable, workflowEnvironment);
-
-            bool forceNode24 = forceNode24Details.IsTrue;
-            bool allowUnsecureNode = allowUnsecureNodeDetails.IsTrue;
-            string warningMessage = null;
-
-            // Check if both flags are set from the same source
-            bool bothFromWorkflow = forceNode24Details.IsTrue && allowUnsecureNodeDetails.IsTrue &&
-                                   forceNode24Details.FromWorkflow && allowUnsecureNodeDetails.FromWorkflow;
-
-            bool bothFromSystem = forceNode24Details.IsTrue && allowUnsecureNodeDetails.IsTrue &&
-                                 forceNode24Details.FromSystem && allowUnsecureNodeDetails.FromSystem;
-
-            // Handle the case when both are set in the same source
-            if (bothFromWorkflow || bothFromSystem)
-            {
-                string source = bothFromWorkflow ? "workflow" : "system";
-                string defaultVersion = useNode24ByDefault ? Constants.Runner.NodeMigration.Node24 : Constants.Runner.NodeMigration.Node20;
-                warningMessage = $"Both {Constants.Runner.NodeMigration.ForceNode24Variable} and {Constants.Runner.NodeMigration.AllowUnsecureNodeVersionVariable} environment variables are set to true in the {source} environment. This is likely a configuration error. Using the default Node version: {defaultVersion}.";
-                return (defaultVersion, warningMessage);
-            }
-
-            // Phase 2: Node 24 is the default
-            if (useNode24ByDefault)
-            {
-                if (allowUnsecureNode)
-                {
-                    return (Constants.Runner.NodeMigration.Node20, null);
-                }
-
-                return (Constants.Runner.NodeMigration.Node24, null);
-            }
-
-            // Phase 1: Node 20 is the default
-            if (forceNode24)
-            {
-                return (Constants.Runner.NodeMigration.Node24, null);
-            }
-
-            return (Constants.Runner.NodeMigration.Node20, null);
-        }
-
-        /// <summary>
-        /// Checks if Node24 is requested but running on ARM32 Linux, and determines if fallback is needed.
-        /// </summary>
-        /// <param name="preferredVersion">The preferred Node version</param>
-        /// <returns>A tuple containing the adjusted node version and an optional warning message</returns>
-        public static (string nodeVersion, string warningMessage) CheckNodeVersionForLinuxArm32(string preferredVersion)
-        {
-            if (string.Equals(preferredVersion, Constants.Runner.NodeMigration.Node24, StringComparison.OrdinalIgnoreCase) &&
-                Constants.Runner.PlatformArchitecture.Equals(Constants.Architecture.Arm) &&
-                Constants.Runner.Platform.Equals(Constants.OSPlatform.Linux))
-            {
-                return (Constants.Runner.NodeMigration.Node20, "Node 24 is not supported on Linux ARM32 platforms. Falling back to Node 20.");
-            }
-
-            return (preferredVersion, null);
-        }
-
-        /// <summary>
-        /// Gets detailed information about an environment variable from both workflow and system environments
-        /// </summary>
-        /// <param name="variableName">The name of the environment variable</param>
-        /// <param name="workflowEnvironment">Optional dictionary containing workflow-level environment variables</param>
-        /// <returns>An EnvironmentVariableInfo object containing details about the variable from both sources</returns>
-        private static EnvironmentVariableInfo GetEnvironmentVariableDetails(string variableName, IDictionary<string, string> workflowEnvironment)
-        {
-            var info = new EnvironmentVariableInfo();
-
-            // Check workflow environment
-            bool foundInWorkflow = false;
-            string workflowValue = null;
-
-            if (workflowEnvironment != null && workflowEnvironment.TryGetValue(variableName, out workflowValue))
-            {
-                foundInWorkflow = true;
-                info.FromWorkflow = true;
-                info.IsTrue = StringUtil.ConvertToBoolean(workflowValue); // Workflow value takes precedence for the boolean value
-            }
-
-            // Also check system environment
-            string systemValue = Environment.GetEnvironmentVariable(variableName);
-            bool foundInSystem = !string.IsNullOrEmpty(systemValue);
-
-            info.FromSystem = foundInSystem;
-
-            // If not found in workflow, use system values
-            if (!foundInWorkflow)
-            {
-                info.IsTrue = StringUtil.ConvertToBoolean(systemValue);
-            }
-
-            return info;
-        }
     }
 }

src/Runner.Listener/BrokerMessageListener.cs

@@ -9,12 +9,11 @@ using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
-using GitHub.Runner.Common.Util;
 using GitHub.Runner.Listener.Configuration;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
+using GitHub.Runner.Common.Util;
 using GitHub.Services.OAuth;
-using GitHub.Services.WebApi;
 
 namespace GitHub.Runner.Listener
 {
@@ -25,234 +24,25 @@ namespace GitHub.Runner.Listener
         private TimeSpan _getNextMessageRetryInterval;
         private TaskAgentStatus runnerStatus = TaskAgentStatus.Online;
         private CancellationTokenSource _getMessagesTokenSource;
-        private VssCredentials _creds;
-        private VssCredentials _credsV2;
-        private TaskAgentSession _session;
-        private IRunnerServer _runnerServer;
         private IBrokerServer _brokerServer;
-        private ICredentialManager _credMgr;
-        private readonly Dictionary<string, int> _sessionCreationExceptionTracker = new();
-        private bool _accessTokenRevoked = false;
-        private readonly TimeSpan _sessionCreationRetryInterval = TimeSpan.FromSeconds(30);
-        private readonly TimeSpan _sessionConflictRetryLimit = TimeSpan.FromMinutes(4);
-        private readonly TimeSpan _clockSkewRetryLimit = TimeSpan.FromMinutes(30);
-        private bool _needRefreshCredsV2 = false;
-        private bool _handlerInitialized = false;
-        private bool _isMigratedSettings = false;
-        private const int _maxMigratedSettingsRetries = 3;
-        private int _migratedSettingsRetryCount = 0;
-
-        public BrokerMessageListener()
-        {
-        }
-
-        public BrokerMessageListener(RunnerSettings settings, bool isMigratedSettings = false)
-        {
-            _settings = settings;
-            _isMigratedSettings = isMigratedSettings;
-        }
 
         public override void Initialize(IHostContext hostContext)
         {
             base.Initialize(hostContext);
 
             _term = HostContext.GetService<ITerminal>();
-            _runnerServer = HostContext.GetService<IRunnerServer>();
             _brokerServer = HostContext.GetService<IBrokerServer>();
-            _credMgr = HostContext.GetService<ICredentialManager>();
         }
 
-        public async Task<CreateSessionResult> CreateSessionAsync(CancellationToken token)
+        public async Task<Boolean> CreateSessionAsync(CancellationToken token)
         {
-            Trace.Entering();
-
-            // Load settings if not provided through constructor
-            if (_settings == null)
-            {
-                var configManager = HostContext.GetService<IConfigurationManager>();
-                _settings = configManager.LoadSettings();
-                Trace.Info("Settings loaded from config manager");
-            }
-            else
-            {
-                Trace.Info("Using provided settings");
-                if (_isMigratedSettings)
-                {
-                    Trace.Info("Using migrated settings from .runner_migrated");
-                }
-            }
-
-            var serverUrlV2 = _settings.ServerUrlV2;
-            var serverUrl = _settings.ServerUrl;
-            Trace.Info(_settings);
-
-            if (string.IsNullOrEmpty(_settings.ServerUrlV2))
-            {
-                throw new InvalidOperationException("ServerUrlV2 is not set");
-            }
-
-            // Create connection.
-            Trace.Info("Loading Credentials");
-            _creds = _credMgr.LoadCredentials(allowAuthUrlV2: false);
-
-            var agent = new TaskAgentReference
-            {
-                Id = _settings.AgentId,
-                Name = _settings.AgentName,
-                Version = BuildConstants.RunnerPackage.Version,
-                OSDescription = RuntimeInformation.OSDescription,
-            };
-            var currentProcess = Process.GetCurrentProcess();
-            string sessionName = $"{Environment.MachineName ?? "RUNNER"} (PID: {currentProcess.Id})";
-            var taskAgentSession = new TaskAgentSession(sessionName, agent);
-
-            string errorMessage = string.Empty;
-            bool encounteringError = false;
-
-            while (true)
-            {
-                token.ThrowIfCancellationRequested();
-                Trace.Info($"Attempt to create session.");
-                try
-                {
-                    Trace.Info("Connecting to the Broker Server...");
-                    _credsV2 = _credMgr.LoadCredentials(allowAuthUrlV2: true);
-                    await _brokerServer.ConnectAsync(new Uri(serverUrlV2), _credsV2);
-                    Trace.Info("VssConnection created");
-
-                    if (!string.IsNullOrEmpty(serverUrl) &&
-                        !string.Equals(serverUrl, serverUrlV2, StringComparison.OrdinalIgnoreCase))
-                    {
-                        Trace.Info("Connecting to the Runner server...");
-                        await _runnerServer.ConnectAsync(new Uri(serverUrl), _creds);
-                        Trace.Info("VssConnection created");
-                    }
-
-                    _term.WriteLine();
-                    _term.WriteSuccessMessage("Connected to GitHub");
-                    _term.WriteLine();
-
-                    _session = await _brokerServer.CreateSessionAsync(taskAgentSession, token);
-
-                    Trace.Info($"Session created.");
-                    if (encounteringError)
-                    {
-                        _term.WriteLine($"{DateTime.UtcNow:u}: Runner reconnected.");
-                        _sessionCreationExceptionTracker.Clear();
-                        encounteringError = false;
-                    }
-
-                    if (!_handlerInitialized)
-                    {
-                        // Register event handler for auth migration state change
-                        HostContext.AuthMigrationChanged += HandleAuthMigrationChanged;
-                        _handlerInitialized = true;
-                    }
-
-                    return CreateSessionResult.Success;
-                }
-                catch (OperationCanceledException) when (token.IsCancellationRequested)
-                {
-                    Trace.Info("Session creation has been cancelled.");
-                    throw;
-                }
-                catch (TaskAgentAccessTokenExpiredException)
-                {
-                    Trace.Info("Runner OAuth token has been revoked. Session creation failed.");
-                    _accessTokenRevoked = true;
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    Trace.Error("Catch exception during create session.");
-                    Trace.Error(ex);
-
-                    // If using migrated settings, limit the number of retries before returning failure
-                    if (_isMigratedSettings)
-                    {
-                        _migratedSettingsRetryCount++;
-                        Trace.Warning($"Migrated settings retry {_migratedSettingsRetryCount} of {_maxMigratedSettingsRetries}");
-                        
-                        if (_migratedSettingsRetryCount >= _maxMigratedSettingsRetries)
-                        {
-                            Trace.Warning("Reached maximum retry attempts for migrated settings. Returning failure to try default settings.");
-                            return CreateSessionResult.Failure;
-                        }
-                    }
-
-                    if (!HostContext.AllowAuthMigration &&
-                        ex is VssOAuthTokenRequestException vssOAuthEx &&
-                        _credsV2.Federated is VssOAuthCredential vssOAuthCred)
-                    {
-                        // "invalid_client" means the runner registration has been deleted from the server.
-                        if (string.Equals(vssOAuthEx.Error, "invalid_client", StringComparison.OrdinalIgnoreCase))
-                        {
-                            _term.WriteError("Failed to create a session. The runner registration has been deleted from the server, please re-configure. Runner registrations are automatically deleted for runners that have not connected to the service recently.");
-                            return CreateSessionResult.Failure;
-                        }
-
-                        // Check whether we get 401 because the runner registration already removed by the service.
-                        // If the runner registration get deleted, we can't exchange oauth token.
-                        Trace.Error("Test oauth app registration.");
-                        var oauthTokenProvider = new VssOAuthTokenProvider(vssOAuthCred, new Uri(serverUrlV2));
-                        var authError = await oauthTokenProvider.ValidateCredentialAsync(token);
-                        if (string.Equals(authError, "invalid_client", StringComparison.OrdinalIgnoreCase))
-                        {
-                            _term.WriteError("Failed to create a session. The runner registration has been deleted from the server, please re-configure. Runner registrations are automatically deleted for runners that have not connected to the service recently.");
-                            return CreateSessionResult.Failure;
-                        }
-                    }
-
-                    if (!HostContext.AllowAuthMigration &&
-                        !IsSessionCreationExceptionRetriable(ex))
-                    {
-                        _term.WriteError($"Failed to create session. {ex.Message}");
-                        if (ex is TaskAgentSessionConflictException)
-                        {
-                            return CreateSessionResult.SessionConflict;
-                        }
-                        return CreateSessionResult.Failure;
-                    }
-
-                    if (HostContext.AllowAuthMigration)
-                    {
-                        Trace.Info("Disable migration mode for 60 minutes.");
-                        HostContext.DeferAuthMigration(TimeSpan.FromMinutes(60), $"Session creation failed with exception: {ex}");
-                    }
-
-                    if (!encounteringError) //print the message only on the first error
-                    {
-                        _term.WriteError($"{DateTime.UtcNow:u}: Runner connect error: {ex.Message}. Retrying until reconnected.");
-                        encounteringError = true;
-                    }
-
-                    Trace.Info("Sleeping for {0} seconds before retrying.", _sessionCreationRetryInterval.TotalSeconds);
-                    await HostContext.Delay(_sessionCreationRetryInterval, token);
-                }
-            }
+            await RefreshBrokerConnection();
+            return await Task.FromResult(true);
         }
 
         public async Task DeleteSessionAsync()
         {
-            if (_session != null && _session.SessionId != Guid.Empty)
-            {
-                if (_handlerInitialized)
-                {
-                    HostContext.AuthMigrationChanged -= HandleAuthMigrationChanged;
-                }
-
-                if (!_accessTokenRevoked)
-                {
-                    using (var ts = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
-                    {
-                        await _brokerServer.DeleteSessionAsync(ts.Token);
-                    }
-                }
-                else
-                {
-                    Trace.Warning("Runner OAuth token has been revoked. Skip deleting session.");
-                }
-            }
+            await Task.CompletedTask;
         }
 
         public void OnJobStatus(object sender, JobStatusEventArgs e)
@@ -283,20 +73,12 @@ namespace GitHub.Runner.Listener
                 _getMessagesTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
                 try
                 {
-                    if (_needRefreshCredsV2)
-                    {
-                        Trace.Info("Refreshing broker connection.");
-                        await RefreshBrokerConnectionAsync();
-                        _needRefreshCredsV2 = false;
-                    }
-
-                    message = await _brokerServer.GetRunnerMessageAsync(_session.SessionId,
+                    message = await _brokerServer.GetRunnerMessageAsync(_getMessagesTokenSource.Token,
                                                                         runnerStatus,
                                                                         BuildConstants.RunnerPackage.Version,
                                                                         VarUtil.OS,
                                                                         VarUtil.OSArchitecture,
-                                                                        _settings.DisableUpdate,
-                                                                        _getMessagesTokenSource.Token);
+                                                                        _settings.DisableUpdate);
 
                     if (message == null)
                     {
@@ -320,16 +102,7 @@ namespace GitHub.Runner.Listener
                     Trace.Info("Runner OAuth token has been revoked. Unable to pull message.");
                     throw;
                 }
-                catch (HostedRunnerDeprovisionedException)
-                {
-                    Trace.Info("Hosted runner has been deprovisioned.");
-                    throw;
-                }
-                catch (AccessDeniedException e) when (e.ErrorCode == 1 && !HostContext.AllowAuthMigration)
-                {
-                    throw;
-                }
-                catch (RunnerNotFoundException) when (!HostContext.AllowAuthMigration)
+                catch (AccessDeniedException e) when (e.ErrorCode == 1)
                 {
                     throw;
                 }
@@ -338,8 +111,7 @@ namespace GitHub.Runner.Listener
                     Trace.Error("Catch exception during get next message.");
                     Trace.Error(ex);
 
-                    if (!HostContext.AllowAuthMigration &&
-                        !IsGetNextMessageExceptionRetriable(ex))
+                    if (!IsGetNextMessageExceptionRetriable(ex))
                     {
                         throw new NonRetryableException("Get next message failed with non-retryable error.", ex);
                     }
@@ -370,14 +142,8 @@ namespace GitHub.Runner.Listener
                             encounteringError = true;
                         }
 
-                        if (HostContext.AllowAuthMigration)
-                        {
-                            Trace.Info("Disable migration mode for 60 minutes.");
-                            HostContext.DeferAuthMigration(TimeSpan.FromMinutes(60), $"Get next message failed with exception: {ex}");
-                        }
-
                         // re-create VssConnection before next retry
-                        await RefreshBrokerConnectionAsync();
+                        await RefreshBrokerConnection();
 
                         Trace.Info("Sleeping for {0} seconds before retrying.", _getNextMessageRetryInterval.TotalSeconds);
                         await HostContext.Delay(_getNextMessageRetryInterval, token);
@@ -407,11 +173,6 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        public async Task RefreshListenerTokenAsync()
-        {
-            await RefreshBrokerConnectionAsync();
-        }
-
         public async Task DeleteMessageAsync(TaskAgentMessage message)
         {
             await Task.CompletedTask;
@@ -423,7 +184,6 @@ namespace GitHub.Runner.Listener
                 ex is TaskAgentPoolNotFoundException ||
                 ex is TaskAgentSessionExpiredException ||
                 ex is AccessDeniedException ||
-                ex is RunnerNotFoundException ||
                 ex is VssUnauthorizedException)
             {
                 Trace.Info($"Non-retriable exception: {ex.Message}");
@@ -436,90 +196,19 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private bool IsSessionCreationExceptionRetriable(Exception ex)
+        private async Task RefreshBrokerConnection()
         {
-            if (ex is TaskAgentNotFoundException)
-            {
-                Trace.Info("The runner no longer exists on the server. Stopping the runner.");
-                _term.WriteError("The runner no longer exists on the server. Please reconfigure the runner.");
-                return false;
-            }
-            else if (ex is TaskAgentSessionConflictException)
-            {
-                Trace.Info("The session for this runner already exists.");
-                _term.WriteError("A session for this runner already exists.");
-                if (_sessionCreationExceptionTracker.ContainsKey(nameof(TaskAgentSessionConflictException)))
-                {
-                    _sessionCreationExceptionTracker[nameof(TaskAgentSessionConflictException)]++;
-                    if (_sessionCreationExceptionTracker[nameof(TaskAgentSessionConflictException)] * _sessionCreationRetryInterval.TotalSeconds >= _sessionConflictRetryLimit.TotalSeconds)
-                    {
-                        Trace.Info("The session conflict exception have reached retry limit.");
-                        _term.WriteError($"Stop retry on SessionConflictException after retried for {_sessionConflictRetryLimit.TotalSeconds} seconds.");
-                        return false;
-                    }
-                }
-                else
-                {
-                    _sessionCreationExceptionTracker[nameof(TaskAgentSessionConflictException)] = 1;
-                }
+            var configManager = HostContext.GetService<IConfigurationManager>();
+            _settings = configManager.LoadSettings();
 
-                Trace.Info("The session conflict exception haven't reached retry limit.");
-                return true;
-            }
-            else if (ex is VssOAuthTokenRequestException && ex.Message.Contains("Current server time is"))
+            if (_settings.ServerUrlV2 == null)
             {
-                Trace.Info("Local clock might be skewed.");
-                _term.WriteError("The local machine's clock may be out of sync with the server time by more than five minutes. Please sync your clock with your domain or internet time and try again.");
-                if (_sessionCreationExceptionTracker.ContainsKey(nameof(VssOAuthTokenRequestException)))
-                {
-                    _sessionCreationExceptionTracker[nameof(VssOAuthTokenRequestException)]++;
-                    if (_sessionCreationExceptionTracker[nameof(VssOAuthTokenRequestException)] * _sessionCreationRetryInterval.TotalSeconds >= _clockSkewRetryLimit.TotalSeconds)
-                    {
-                        Trace.Info("The OAuth token request exception have reached retry limit.");
-                        _term.WriteError($"Stopped retrying OAuth token request exception after {_clockSkewRetryLimit.TotalSeconds} seconds.");
-                        return false;
-                    }
-                }
-                else
-                {
-                    _sessionCreationExceptionTracker[nameof(VssOAuthTokenRequestException)] = 1;
-                }
-
-                Trace.Info("The OAuth token request exception haven't reached retry limit.");
-                return true;
-            }
-            else if (ex is TaskAgentPoolNotFoundException ||
-                     ex is AccessDeniedException ||
-                     ex is VssUnauthorizedException)
-            {
-                Trace.Info($"Non-retriable exception: {ex.Message}");
-                return false;
+                throw new InvalidOperationException("ServerUrlV2 is not set");
             }
 
-            else if (ex is InvalidOperationException)
-            {
-                Trace.Info($"Non-retriable exception: {ex.Message}");
-                return false;
-            }
-            else
-            {
-                Trace.Info($"Retriable exception: {ex.Message}");
-                return true;
-            }
-        }
-
-        private async Task RefreshBrokerConnectionAsync()
-        {
-            Trace.Info("Reload credentials.");
-            _credsV2 = _credMgr.LoadCredentials(allowAuthUrlV2: true);
-            await _brokerServer.ConnectAsync(new Uri(_settings.ServerUrlV2), _credsV2);
-            Trace.Info("Connection to Broker Server recreated.");
-        }
-
-        private void HandleAuthMigrationChanged(object sender, EventArgs e)
-        {
-            Trace.Info($"Auth migration changed. Current allow auth migration state: {HostContext.AllowAuthMigration}");
-            _needRefreshCredsV2 = true;
+            var credMgr = HostContext.GetService<ICredentialManager>();
+            VssCredentials creds = credMgr.LoadCredentials();
+            await _brokerServer.ConnectAsync(new Uri(_settings.ServerUrlV2), creds);
         }
     }
 }

src/Runner.Listener/Checks/ActionsCheck.cs

@@ -39,7 +39,6 @@ namespace GitHub.Runner.Listener.Check
             string githubApiUrl = null;
             string actionsTokenServiceUrl = null;
             string actionsPipelinesServiceUrl = null;
-            string resultsReceiverServiceUrl = null;
             var urlBuilder = new UriBuilder(url);
             if (UrlUtil.IsHostedServer(urlBuilder))
             {
@@ -48,7 +47,6 @@ namespace GitHub.Runner.Listener.Check
                 githubApiUrl = urlBuilder.Uri.AbsoluteUri;
                 actionsTokenServiceUrl = "https://vstoken.actions.githubusercontent.com/_apis/health";
                 actionsPipelinesServiceUrl = "https://pipelines.actions.githubusercontent.com/_apis/health";
-                resultsReceiverServiceUrl = "https://results-receiver.actions.githubusercontent.com/health";
             }
             else
             {
@@ -58,31 +56,13 @@ namespace GitHub.Runner.Listener.Check
                 actionsTokenServiceUrl = urlBuilder.Uri.AbsoluteUri;
                 urlBuilder.Path = "_services/pipelines/_apis/health";
                 actionsPipelinesServiceUrl = urlBuilder.Uri.AbsoluteUri;
-                resultsReceiverServiceUrl = string.Empty; // we don't have Results service in GHES yet.
             }
 
-            var codeLoadUrlBuilder = new UriBuilder(url);
-            codeLoadUrlBuilder.Host = $"codeload.{codeLoadUrlBuilder.Host}";
-            codeLoadUrlBuilder.Path = "_ping";
-
             // check github api
             checkTasks.Add(CheckUtil.CheckDns(githubApiUrl));
             checkTasks.Add(CheckUtil.CheckPing(githubApiUrl));
             checkTasks.Add(HostContext.CheckHttpsGetRequests(githubApiUrl, pat, expectedHeader: "X-GitHub-Request-Id"));
 
-            // check github codeload
-            checkTasks.Add(CheckUtil.CheckDns(codeLoadUrlBuilder.Uri.AbsoluteUri));
-            checkTasks.Add(CheckUtil.CheckPing(codeLoadUrlBuilder.Uri.AbsoluteUri));
-            checkTasks.Add(HostContext.CheckHttpsGetRequests(codeLoadUrlBuilder.Uri.AbsoluteUri, pat, expectedHeader: "X-GitHub-Request-Id"));
-
-            // check results-receiver service
-            if (!string.IsNullOrEmpty(resultsReceiverServiceUrl))
-            {
-                checkTasks.Add(CheckUtil.CheckDns(resultsReceiverServiceUrl));
-                checkTasks.Add(CheckUtil.CheckPing(resultsReceiverServiceUrl));
-                checkTasks.Add(HostContext.CheckHttpsGetRequests(resultsReceiverServiceUrl, pat, expectedHeader: "X-GitHub-Request-Id"));
-            }
-
             // check actions token service
             checkTasks.Add(CheckUtil.CheckDns(actionsTokenServiceUrl));
             checkTasks.Add(CheckUtil.CheckPing(actionsTokenServiceUrl));

src/Runner.Listener/Configuration/ConfigurationManager.cs

@@ -25,7 +25,6 @@ namespace GitHub.Runner.Listener.Configuration
         Task UnconfigureAsync(CommandSettings command);
         void DeleteLocalRunnerConfig();
         RunnerSettings LoadSettings();
-        RunnerSettings LoadMigratedSettings();
     }
 
     public sealed class ConfigurationManager : RunnerService, IConfigurationManager
@@ -67,22 +66,6 @@ namespace GitHub.Runner.Listener.Configuration
             return settings;
         }
 
-        public RunnerSettings LoadMigratedSettings()
-        {
-            Trace.Info(nameof(LoadMigratedSettings));
-
-            // Check if migrated settings file exists
-            if (!_store.IsMigratedConfigured())
-            {
-                throw new NonRetryableException("No migrated configuration found.");
-            }
-
-            RunnerSettings settings = _store.GetMigratedSettings();
-            Trace.Info("Migrated Settings Loaded");
-
-            return settings;
-        }
-
         public async Task ConfigureAsync(CommandSettings command)
         {
             _term.WriteLine();
@@ -144,7 +127,7 @@ namespace GitHub.Runner.Listener.Configuration
                     runnerSettings.ServerUrl = inputUrl;
                     // Get the credentials
                     credProvider = GetCredentialProvider(command, runnerSettings.ServerUrl);
-                    creds = credProvider.GetVssCredentials(HostContext, allowAuthUrlV2: false);
+                    creds = credProvider.GetVssCredentials(HostContext);
                     Trace.Info("legacy vss cred retrieved");
                 }
                 else
@@ -383,18 +366,10 @@ namespace GitHub.Runner.Listener.Configuration
                     {
                         { "clientId", agent.Authorization.ClientId.ToString("D") },
                         { "authorizationUrl", agent.Authorization.AuthorizationUrl.AbsoluteUri },
-                        { "requireFipsCryptography", agent.Properties.GetValue("RequireFipsCryptography", true).ToString() }
+                        { "requireFipsCryptography", agent.Properties.GetValue("RequireFipsCryptography", false).ToString() }
                     },
                 };
 
-                if (agent.Properties.GetValue("EnableAuthMigrationByDefault", false) &&
-                    agent.Properties.TryGetValue<string>("AuthorizationUrlV2", out var authUrlV2) &&
-                    !string.IsNullOrEmpty(authUrlV2))
-                {
-                    credentialData.Data["enableAuthMigrationByDefault"] = "true";
-                    credentialData.Data["authorizationUrlV2"] = authUrlV2;
-                }
-
                 // Save the negotiated OAuth credential data
                 _store.SaveCredential(credentialData);
             }
@@ -409,7 +384,7 @@ namespace GitHub.Runner.Listener.Configuration
             if (!runnerSettings.UseV2Flow)
             {
                 var credMgr = HostContext.GetService<ICredentialManager>();
-                VssCredentials credential = credMgr.LoadCredentials(allowAuthUrlV2: false);
+                VssCredentials credential = credMgr.LoadCredentials();
                 try
                 {
                     await _runnerServer.ConnectAsync(new Uri(runnerSettings.ServerUrl), credential);
@@ -429,20 +404,6 @@ namespace GitHub.Runner.Listener.Configuration
                 }
             }
 
-            // allow the server to override the serverUrlV2 and useV2Flow
-            if (agent.Properties.TryGetValue("ServerUrlV2", out string serverUrlV2) &&
-                !string.IsNullOrEmpty(serverUrlV2))
-            {
-                Trace.Info($"Service enforced serverUrlV2: {serverUrlV2}");
-                runnerSettings.ServerUrlV2 = serverUrlV2;
-            }
-
-            if (agent.Properties.TryGetValue("UseV2Flow", out bool useV2Flow) && useV2Flow)
-            {
-                Trace.Info($"Service enforced useV2Flow: {useV2Flow}");
-                runnerSettings.UseV2Flow = useV2Flow;
-            }
-
             _term.WriteSection("Runner settings");
 
             // We will Combine() what's stored with root.  Defaults to string a relative path
@@ -537,50 +498,41 @@ namespace GitHub.Runner.Listener.Configuration
                 if (isConfigured && hasCredentials)
                 {
                     RunnerSettings settings = _store.GetSettings();
+                    var credentialManager = HostContext.GetService<ICredentialManager>();
 
-                    if (settings.UseV2Flow)
+                    // Get the credentials
+                    VssCredentials creds = null;
+                    if (string.IsNullOrEmpty(settings.GitHubUrl))
                     {
-                        var deletionToken = await GetRunnerTokenAsync(command, settings.GitHubUrl, "remove");
-                        await _dotcomServer.DeleteRunnerAsync(settings.GitHubUrl, deletionToken, settings.AgentId);
+                        var credProvider = GetCredentialProvider(command, settings.ServerUrl);
+                        creds = credProvider.GetVssCredentials(HostContext);
+                        Trace.Info("legacy vss cred retrieved");
                     }
                     else
                     {
-                        var credentialManager = HostContext.GetService<ICredentialManager>();
-
-                        // Get the credentials
-                        VssCredentials creds = null;
-                        if (string.IsNullOrEmpty(settings.GitHubUrl))
-                        {
-                            var credProvider = GetCredentialProvider(command, settings.ServerUrl);
-                            creds = credProvider.GetVssCredentials(HostContext, allowAuthUrlV2: false);
-                            Trace.Info("legacy vss cred retrieved");
-                        }
-                        else
-                        {
-                            var deletionToken = await GetRunnerTokenAsync(command, settings.GitHubUrl, "remove");
-                            GitHubAuthResult authResult = await GetTenantCredential(settings.GitHubUrl, deletionToken, Constants.RunnerEvent.Remove);
-                            creds = authResult.ToVssCredentials();
-                            Trace.Info("cred retrieved via GitHub auth");
-                        }
-
-                        // Determine the service deployment type based on connection data. (Hosted/OnPremises)
-                        await _runnerServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
-
-                        var agents = await _runnerServer.GetAgentsAsync(settings.AgentName);
-                        Trace.Verbose("Returns {0} agents", agents.Count);
-                        TaskAgent agent = agents.FirstOrDefault();
-                        if (agent == null)
-                        {
-                            _term.WriteLine("Does not exist. Skipping " + currentAction);
-                        }
-                        else
-                        {
-                            await _runnerServer.DeleteAgentAsync(settings.AgentId);
-                        }
+                        var deletionToken = await GetRunnerTokenAsync(command, settings.GitHubUrl, "remove");
+                        GitHubAuthResult authResult = await GetTenantCredential(settings.GitHubUrl, deletionToken, Constants.RunnerEvent.Remove);
+                        creds = authResult.ToVssCredentials();
+                        Trace.Info("cred retrieved via GitHub auth");
                     }
 
-                    _term.WriteLine();
-                    _term.WriteSuccessMessage("Runner removed successfully");
+                    // Determine the service deployment type based on connection data. (Hosted/OnPremises)
+                    await _runnerServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
+
+                    var agents = await _runnerServer.GetAgentsAsync(settings.AgentName);
+                    Trace.Verbose("Returns {0} agents", agents.Count);
+                    TaskAgent agent = agents.FirstOrDefault();
+                    if (agent == null)
+                    {
+                        _term.WriteLine("Does not exist. Skipping " + currentAction);
+                    }
+                    else
+                    {
+                        await _runnerServer.DeleteAgentAsync(settings.AgentId);
+
+                        _term.WriteLine();
+                        _term.WriteSuccessMessage("Runner removed successfully");
+                    }
                 }
                 else
                 {

src/Runner.Listener/Configuration/CredentialManager.cs

@@ -13,7 +13,7 @@ namespace GitHub.Runner.Listener.Configuration
     public interface ICredentialManager : IRunnerService
     {
         ICredentialProvider GetCredentialProvider(string credType);
-        VssCredentials LoadCredentials(bool allowAuthUrlV2);
+        VssCredentials LoadCredentials();
     }
 
     public class CredentialManager : RunnerService, ICredentialManager
@@ -40,7 +40,7 @@ namespace GitHub.Runner.Listener.Configuration
             return creds;
         }
 
-        public VssCredentials LoadCredentials(bool allowAuthUrlV2)
+        public VssCredentials LoadCredentials()
         {
             IConfigurationStore store = HostContext.GetService<IConfigurationStore>();
 
@@ -51,16 +51,21 @@ namespace GitHub.Runner.Listener.Configuration
 
             CredentialData credData = store.GetCredentials();
             var migratedCred = store.GetMigratedCredentials();
-            if (migratedCred != null &&
-                migratedCred.Scheme == Constants.Configuration.OAuth)
+            if (migratedCred != null)
             {
                 credData = migratedCred;
+
+                // Re-write .credentials with Token URL
+                store.SaveCredential(credData);
+
+                // Delete .credentials_migrated
+                store.DeleteMigratedCredential();
             }
 
             ICredentialProvider credProv = GetCredentialProvider(credData.Scheme);
             credProv.CredentialData = credData;
 
-            VssCredentials creds = credProv.GetVssCredentials(HostContext, allowAuthUrlV2);
+            VssCredentials creds = credProv.GetVssCredentials(HostContext);
 
             return creds;
         }

src/Runner.Listener/Configuration/CredentialProvider.cs

@@ -1,7 +1,7 @@
 using System;
+using GitHub.Services.Common;
 using GitHub.Runner.Common;
 using GitHub.Runner.Sdk;
-using GitHub.Services.Common;
 using GitHub.Services.OAuth;
 
 namespace GitHub.Runner.Listener.Configuration
@@ -10,7 +10,7 @@ namespace GitHub.Runner.Listener.Configuration
     {
         Boolean RequireInteractive { get; }
         CredentialData CredentialData { get; set; }
-        VssCredentials GetVssCredentials(IHostContext context, bool allowAuthUrlV2);
+        VssCredentials GetVssCredentials(IHostContext context);
         void EnsureCredential(IHostContext context, CommandSettings command, string serverUrl);
     }
 
@@ -25,7 +25,7 @@ namespace GitHub.Runner.Listener.Configuration
         public virtual Boolean RequireInteractive => false;
         public CredentialData CredentialData { get; set; }
 
-        public abstract VssCredentials GetVssCredentials(IHostContext context, bool allowAuthUrlV2);
+        public abstract VssCredentials GetVssCredentials(IHostContext context);
         public abstract void EnsureCredential(IHostContext context, CommandSettings command, string serverUrl);
     }
 
@@ -33,7 +33,7 @@ namespace GitHub.Runner.Listener.Configuration
     {
         public OAuthAccessTokenCredential() : base(Constants.Configuration.OAuthAccessToken) { }
 
-        public override VssCredentials GetVssCredentials(IHostContext context, bool allowAuthUrlV2)
+        public override VssCredentials GetVssCredentials(IHostContext context)
         {
             ArgUtil.NotNull(context, nameof(context));
             Tracing trace = context.GetTrace(nameof(OAuthAccessTokenCredential));

src/Runner.Listener/Configuration/OAuthCredential.cs

@@ -22,18 +22,10 @@ namespace GitHub.Runner.Listener.Configuration
             // Nothing to verify here
         }
 
-        public override VssCredentials GetVssCredentials(IHostContext context, bool allowAuthUrlV2)
+        public override VssCredentials GetVssCredentials(IHostContext context)
         {
             var clientId = this.CredentialData.Data.GetValueOrDefault("clientId", null);
             var authorizationUrl = this.CredentialData.Data.GetValueOrDefault("authorizationUrl", null);
-            var authorizationUrlV2 = this.CredentialData.Data.GetValueOrDefault("authorizationUrlV2", null);
-
-            if (allowAuthUrlV2 &&
-                !string.IsNullOrEmpty(authorizationUrlV2) &&
-                context.AllowAuthMigration)
-            {
-                authorizationUrl = authorizationUrlV2;
-            }
 
             // For back compat with .credential file that doesn't has 'oauthEndpointUrl' section
             var oauthEndpointUrl = this.CredentialData.Data.GetValueOrDefault("oauthEndpointUrl", authorizationUrl);

src/Runner.Listener/Configuration/RSAEncryptedFileKeyManager.cs

@@ -1,5 +1,4 @@
 #if OS_WINDOWS
-#pragma warning disable CA1416
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
@@ -85,5 +84,4 @@ namespace GitHub.Runner.Listener.Configuration
         }
     }
 }
-#pragma warning restore CA1416
 #endif

src/Runner.Listener/ErrorThrottler.cs

@@ -1,44 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using GitHub.Runner.Common;
-using GitHub.Services.Common;
-
-namespace GitHub.Runner.Listener
-{
-    [ServiceLocator(Default = typeof(ErrorThrottler))]
-    public interface IErrorThrottler : IRunnerService
-    {
-        void Reset();
-        Task IncrementAndWaitAsync(CancellationToken token);
-    }
-
-    public sealed class ErrorThrottler : RunnerService, IErrorThrottler
-    {
-        internal static readonly TimeSpan MinBackoff = TimeSpan.FromSeconds(1);
-        internal static readonly TimeSpan MaxBackoff = TimeSpan.FromMinutes(1);
-        internal static readonly TimeSpan BackoffCoefficient = TimeSpan.FromSeconds(1);
-        private int _count = 0;
-
-        public void Reset()
-        {
-            _count = 0;
-        }
-
-        public async Task IncrementAndWaitAsync(CancellationToken token)
-        {
-            if (++_count <= 1)
-            {
-                return;
-            }
-
-            TimeSpan backoff = BackoffTimerHelper.GetExponentialBackoff(
-                attempt: _count - 2, // 0-based attempt
-                minBackoff: MinBackoff,
-                maxBackoff: MaxBackoff,
-                deltaBackoff: BackoffCoefficient);
-            Trace.Warning($"Back off {backoff.TotalSeconds} seconds before next attempt. Current consecutive error count: {_count}");
-            await HostContext.Delay(backoff, token);
-        }
-    }
-}

src/Runner.Listener/JobDispatcher.cs

@@ -35,7 +35,7 @@ namespace GitHub.Runner.Listener
     // This implementation of IJobDispatcher is not thread safe.
     // It is based on the fact that the current design of the runner is a dequeue
     // and processes one message from the message queue at a time.
-    // In addition, it only executes one job every time,
+    // In addition, it only executes one job every time, 
     // and the server will not send another job while this one is still running.
     public sealed class JobDispatcher : RunnerService, IJobDispatcher
     {
@@ -110,12 +110,7 @@ namespace GitHub.Runner.Listener
             {
                 var jwt = JsonWebToken.Create(accessToken);
                 var claims = jwt.ExtractClaims();
-                orchestrationId = claims.FirstOrDefault(x => string.Equals(x.Type, "orch_id", StringComparison.OrdinalIgnoreCase))?.Value;
-                if (string.IsNullOrEmpty(orchestrationId))
-                {
-                    orchestrationId = claims.FirstOrDefault(x => string.Equals(x.Type, "orchid", StringComparison.OrdinalIgnoreCase))?.Value;
-                }
-
+                orchestrationId = claims.FirstOrDefault(x => string.Equals(x.Type, "orchid", StringComparison.OrdinalIgnoreCase))?.Value;
                 if (!string.IsNullOrEmpty(orchestrationId))
                 {
                     Trace.Info($"Pull OrchestrationId {orchestrationId} from JWT claims");
@@ -550,36 +545,14 @@ namespace GitHub.Runner.Listener
                                     detailInfo = string.Join(Environment.NewLine, workerOutput);
                                     Trace.Info($"Return code {returnCode} indicate worker encounter an unhandled exception or app crash, attach worker stdout/stderr to JobRequest result.");
 
-                                    try
-                                    {
-                                        var jobServer = await InitializeJobServerAsync(systemConnection);
-                                        var unhandledExceptionIssue = new Issue() { Type = IssueType.Error, Message = detailInfo };
-                                        unhandledExceptionIssue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.WorkerCrash;
-                                        switch (jobServer)
-                                        {
-                                            case IJobServer js:
-                                                {
-                                                    await LogWorkerProcessUnhandledException(js, message, unhandledExceptionIssue);
-                                                    // Go ahead to finish the job with result 'Failed' if the STDERR from worker is System.IO.IOException, since it typically means we are running out of disk space.
-                                                    if (detailInfo.Contains(typeof(System.IO.IOException).ToString(), StringComparison.OrdinalIgnoreCase))
-                                                    {
-                                                        Trace.Info($"Finish job with result 'Failed' due to IOException.");
-                                                        await ForceFailJob(js, message);
-                                                    }
+                                    var jobServer = await InitializeJobServerAsync(systemConnection);
+                                    await LogWorkerProcessUnhandledException(jobServer, message, detailInfo);
 
-                                                    break;
-                                                }
-                                            case IRunServer rs:
-                                                await ForceFailJob(rs, message, unhandledExceptionIssue);
-                                                break;
-                                            default:
-                                                throw new NotSupportedException($"JobServer type '{jobServer.GetType().Name}' is not supported.");
-                                        }
-                                    }
-                                    catch (Exception ex)
+                                    // Go ahead to finish the job with result 'Failed' if the STDERR from worker is System.IO.IOException, since it typically means we are running out of disk space.
+                                    if (detailInfo.Contains(typeof(System.IO.IOException).ToString(), StringComparison.OrdinalIgnoreCase))
                                     {
-                                        Trace.Error($"Catch exception during log worker process unhandled exception.");
-                                        Trace.Error(ex);
+                                        Trace.Info($"Finish job with result 'Failed' due to IOException.");
+                                        await ForceFailJob(jobServer, message, detailInfo);
                                     }
                                 }
 
@@ -656,22 +629,8 @@ namespace GitHub.Runner.Listener
                                     Trace.Info("worker process has been killed.");
                                 }
                             }
-                            catch (Exception ex)
-                            {
-                                // message send failed, this might indicate worker process is already exited or stuck.
-                                Trace.Info($"Job cancel message sending for job {message.JobId} failed, kill running worker. {ex}");
-                                workerProcessCancelTokenSource.Cancel();
-                                try
-                                {
-                                    await workerProcessTask;
-                                }
-                                catch (OperationCanceledException)
-                                {
-                                    Trace.Info("worker process has been killed.");
-                                }
-                            }
 
-                            // wait worker to exit
+                            // wait worker to exit 
                             // if worker doesn't exit within timeout, then kill worker.
                             completedTask = await Task.WhenAny(workerProcessTask, Task.Delay(-1, workerCancelTimeoutKillToken));
 
@@ -1158,65 +1117,77 @@ namespace GitHub.Runner.Listener
         }
 
         // log an error issue to job level timeline record
-        private async Task LogWorkerProcessUnhandledException(IJobServer jobServer, Pipelines.AgentJobRequestMessage message, Issue issue)
+        private async Task LogWorkerProcessUnhandledException(IRunnerService server, Pipelines.AgentJobRequestMessage message, string detailInfo)
         {
-            try
+            if (server is IJobServer jobServer)
             {
-                var timeline = await jobServer.GetTimelineAsync(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, message.Timeline.Id, CancellationToken.None);
-                ArgUtil.NotNull(timeline, nameof(timeline));
+                try
+                {
+                    var timeline = await jobServer.GetTimelineAsync(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, message.Timeline.Id, CancellationToken.None);
+                    ArgUtil.NotNull(timeline, nameof(timeline));
 
-                TimelineRecord jobRecord = timeline.Records.FirstOrDefault(x => x.Id == message.JobId && x.RecordType == "Job");
-                ArgUtil.NotNull(jobRecord, nameof(jobRecord));
+                    TimelineRecord jobRecord = timeline.Records.FirstOrDefault(x => x.Id == message.JobId && x.RecordType == "Job");
+                    ArgUtil.NotNull(jobRecord, nameof(jobRecord));
 
-                jobRecord.ErrorCount++;
-                jobRecord.Issues.Add(issue);
+                    var unhandledExceptionIssue = new Issue() { Type = IssueType.Error, Message = detailInfo };
+                    unhandledExceptionIssue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.WorkerCrash;
+                    jobRecord.ErrorCount++;
+                    jobRecord.Issues.Add(unhandledExceptionIssue);
 
-                Trace.Info("Mark the job as failed since the worker crashed");
-                jobRecord.Result = TaskResult.Failed;
-                // mark the job as completed so service will pickup the result
-                jobRecord.State = TimelineRecordState.Completed;
-
-                await jobServer.UpdateTimelineRecordsAsync(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, message.Timeline.Id, new TimelineRecord[] { jobRecord }, CancellationToken.None);
+                    await jobServer.UpdateTimelineRecordsAsync(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, message.Timeline.Id, new TimelineRecord[] { jobRecord }, CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    Trace.Error("Fail to report unhandled exception from Runner.Worker process");
+                    Trace.Error(ex);
+                }
             }
-            catch (Exception ex)
+            else
             {
-                Trace.Error("Fail to report unhandled exception from Runner.Worker process");
-                Trace.Error(ex);
+                Trace.Info("Job server does not support handling unhandled exception yet, error message: {0}", detailInfo);
+                return;
             }
         }
 
         // raise job completed event to fail the job.
-        private async Task ForceFailJob(IJobServer jobServer, Pipelines.AgentJobRequestMessage message)
+        private async Task ForceFailJob(IRunnerService server, Pipelines.AgentJobRequestMessage message, string detailInfo)
         {
-            try
+            if (server is IJobServer jobServer)
             {
-                var jobCompletedEvent = new JobCompletedEvent(message.RequestId, message.JobId, TaskResult.Failed);
-                await jobServer.RaisePlanEventAsync<JobCompletedEvent>(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, jobCompletedEvent, CancellationToken.None);
-            }
-            catch (Exception ex)
-            {
-                Trace.Error("Fail to raise JobCompletedEvent back to service.");
-                Trace.Error(ex);
-            }
-        }
-
-        private async Task ForceFailJob(IRunServer runServer, Pipelines.AgentJobRequestMessage message, Issue issue)
-        {
-            try
-            {
-                var annotation = issue.ToAnnotation();
-                var jobAnnotations = new List<Annotation>();
-                if (annotation.HasValue)
+                try
                 {
-                    jobAnnotations.Add(annotation.Value);
+                    var jobCompletedEvent = new JobCompletedEvent(message.RequestId, message.JobId, TaskResult.Failed);
+                    await jobServer.RaisePlanEventAsync<JobCompletedEvent>(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, jobCompletedEvent, CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    Trace.Error("Fail to raise JobCompletedEvent back to service.");
+                    Trace.Error(ex);
                 }
-
-                await runServer.CompleteJobAsync(message.Plan.PlanId, message.JobId, TaskResult.Failed, outputs: null, stepResults: null, jobAnnotations: jobAnnotations, environmentUrl: null, telemetry: null, billingOwnerId: message.BillingOwnerId, CancellationToken.None);
             }
-            catch (Exception ex)
+            else if (server is IRunServer runServer)
             {
-                Trace.Error("Fail to raise job completion back to service.");
-                Trace.Error(ex);
+                try
+                {
+                    var unhandledExceptionIssue = new Issue() { Type = IssueType.Error, Message = detailInfo };
+                    var unhandledAnnotation = unhandledExceptionIssue.ToAnnotation();
+                    var jobAnnotations = new List<Annotation>();
+                    if (unhandledAnnotation.HasValue)
+                    {
+                        jobAnnotations.Add(unhandledAnnotation.Value);
+                    }
+
+                    await runServer.CompleteJobAsync(message.Plan.PlanId, message.JobId, TaskResult.Failed, outputs: null, stepResults: null, jobAnnotations: jobAnnotations, environmentUrl: null, CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    Trace.Error("Fail to raise job completion back to service.");
+                    Trace.Error(ex);
+                }
+            }
+            else
+            {
+                throw new NotSupportedException($"Server type {server.GetType().FullName} is not supported.");
             }
         }
 

src/Runner.Listener/MessageListener.cs

@@ -14,26 +14,16 @@ using GitHub.Runner.Listener.Configuration;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using GitHub.Services.OAuth;
-using GitHub.Services.WebApi;
 
 namespace GitHub.Runner.Listener
 {
-    public enum CreateSessionResult
-    {
-        Success,
-        Failure,
-        SessionConflict
-    }
-
     [ServiceLocator(Default = typeof(MessageListener))]
     public interface IMessageListener : IRunnerService
     {
-        Task<CreateSessionResult> CreateSessionAsync(CancellationToken token);
+        Task<Boolean> CreateSessionAsync(CancellationToken token);
         Task DeleteSessionAsync();
         Task<TaskAgentMessage> GetNextMessageAsync(CancellationToken token);
         Task DeleteMessageAsync(TaskAgentMessage message);
-
-        Task RefreshListenerTokenAsync();
         void OnJobStatus(object sender, JobStatusEventArgs e);
     }
 
@@ -43,8 +33,6 @@ namespace GitHub.Runner.Listener
         private RunnerSettings _settings;
         private ITerminal _term;
         private IRunnerServer _runnerServer;
-        private IBrokerServer _brokerServer;
-        private ICredentialManager _credMgr;
         private TaskAgentSession _session;
         private TimeSpan _getNextMessageRetryInterval;
         private bool _accessTokenRevoked = false;
@@ -54,10 +42,6 @@ namespace GitHub.Runner.Listener
         private readonly Dictionary<string, int> _sessionCreationExceptionTracker = new();
         private TaskAgentStatus runnerStatus = TaskAgentStatus.Online;
         private CancellationTokenSource _getMessagesTokenSource;
-        private VssCredentials _creds;
-        private VssCredentials _credsV2;
-        private bool _needRefreshCredsV2 = false;
-        private bool _handlerInitialized = false;
 
         public override void Initialize(IHostContext hostContext)
         {
@@ -65,11 +49,9 @@ namespace GitHub.Runner.Listener
 
             _term = HostContext.GetService<ITerminal>();
             _runnerServer = HostContext.GetService<IRunnerServer>();
-            _brokerServer = hostContext.GetService<IBrokerServer>();
-            _credMgr = hostContext.GetService<ICredentialManager>();
         }
 
-        public async Task<CreateSessionResult> CreateSessionAsync(CancellationToken token)
+        public async Task<Boolean> CreateSessionAsync(CancellationToken token)
         {
             Trace.Entering();
 
@@ -81,7 +63,8 @@ namespace GitHub.Runner.Listener
 
             // Create connection.
             Trace.Info("Loading Credentials");
-            _creds = _credMgr.LoadCredentials(allowAuthUrlV2: false);
+            var credMgr = HostContext.GetService<ICredentialManager>();
+            VssCredentials creds = credMgr.LoadCredentials();
 
             var agent = new TaskAgentReference
             {
@@ -90,8 +73,7 @@ namespace GitHub.Runner.Listener
                 Version = BuildConstants.RunnerPackage.Version,
                 OSDescription = RuntimeInformation.OSDescription,
             };
-            var currentProcess = Process.GetCurrentProcess();
-            string sessionName = $"{Environment.MachineName ?? "RUNNER"} (PID: {currentProcess.Id})";
+            string sessionName = $"{Environment.MachineName ?? "RUNNER"}";
             var taskAgentSession = new TaskAgentSession(sessionName, agent);
 
             string errorMessage = string.Empty;
@@ -104,7 +86,7 @@ namespace GitHub.Runner.Listener
                 try
                 {
                     Trace.Info("Connecting to the Runner Server...");
-                    await _runnerServer.ConnectAsync(new Uri(serverUrl), _creds);
+                    await _runnerServer.ConnectAsync(new Uri(serverUrl), creds);
                     Trace.Info("VssConnection created");
 
                     _term.WriteLine();
@@ -115,6 +97,7 @@ namespace GitHub.Runner.Listener
                                                         _settings.PoolId,
                                                         taskAgentSession,
                                                         token);
+
                     Trace.Info($"Session created.");
                     if (encounteringError)
                     {
@@ -123,14 +106,7 @@ namespace GitHub.Runner.Listener
                         encounteringError = false;
                     }
 
-                    if (!_handlerInitialized)
-                    {
-                        Trace.Info("Registering AuthMigrationChanged event handler.");
-                        HostContext.AuthMigrationChanged += HandleAuthMigrationChanged;
-                        _handlerInitialized = true;
-                    }
-
-                    return CreateSessionResult.Success;
+                    return true;
                 }
                 catch (OperationCanceledException) when (token.IsCancellationRequested)
                 {
@@ -148,13 +124,13 @@ namespace GitHub.Runner.Listener
                     Trace.Error("Catch exception during create session.");
                     Trace.Error(ex);
 
-                    if (ex is VssOAuthTokenRequestException vssOAuthEx && _creds.Federated is VssOAuthCredential vssOAuthCred)
+                    if (ex is VssOAuthTokenRequestException vssOAuthEx && creds.Federated is VssOAuthCredential vssOAuthCred)
                     {
                         // "invalid_client" means the runner registration has been deleted from the server.
                         if (string.Equals(vssOAuthEx.Error, "invalid_client", StringComparison.OrdinalIgnoreCase))
                         {
                             _term.WriteError("Failed to create a session. The runner registration has been deleted from the server, please re-configure. Runner registrations are automatically deleted for runners that have not connected to the service recently.");
-                            return CreateSessionResult.Failure;
+                            return false;
                         }
 
                         // Check whether we get 401 because the runner registration already removed by the service.
@@ -165,18 +141,14 @@ namespace GitHub.Runner.Listener
                         if (string.Equals(authError, "invalid_client", StringComparison.OrdinalIgnoreCase))
                         {
                             _term.WriteError("Failed to create a session. The runner registration has been deleted from the server, please re-configure. Runner registrations are automatically deleted for runners that have not connected to the service recently.");
-                            return CreateSessionResult.Failure;
+                            return false;
                         }
                     }
 
                     if (!IsSessionCreationExceptionRetriable(ex))
                     {
                         _term.WriteError($"Failed to create session. {ex.Message}");
-                        if (ex is TaskAgentSessionConflictException)
-                        {
-                            return CreateSessionResult.SessionConflict;
-                        }
-                        return CreateSessionResult.Failure;
+                        return false;
                     }
 
                     if (!encounteringError) //print the message only on the first error
@@ -195,11 +167,6 @@ namespace GitHub.Runner.Listener
         {
             if (_session != null && _session.SessionId != Guid.Empty)
             {
-                if (_handlerInitialized)
-                {
-                    HostContext.AuthMigrationChanged -= HandleAuthMigrationChanged;
-                }
-
                 if (!_accessTokenRevoked)
                 {
                     using (var ts = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
@@ -216,17 +183,19 @@ namespace GitHub.Runner.Listener
 
         public void OnJobStatus(object sender, JobStatusEventArgs e)
         {
-            Trace.Info("Received job status event. JobState: {0}", e.Status);
-            runnerStatus = e.Status;
-            try
+            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("USE_BROKER_FLOW")))
             {
-                _getMessagesTokenSource?.Cancel();
+                Trace.Info("Received job status event. JobState: {0}", e.Status);
+                runnerStatus = e.Status;
+                try
+                {
+                    _getMessagesTokenSource?.Cancel();
+                }
+                catch (ObjectDisposedException)
+                {
+                    Trace.Info("_getMessagesTokenSource is already disposed.");
+                }
             }
-            catch (ObjectDisposedException)
-            {
-                Trace.Info("_getMessagesTokenSource is already disposed.");
-            }
-
         }
 
         public async Task<TaskAgentMessage> GetNextMessageAsync(CancellationToken token)
@@ -236,7 +205,6 @@ namespace GitHub.Runner.Listener
             ArgUtil.NotNull(_settings, nameof(_settings));
             bool encounteringError = false;
             int continuousError = 0;
-            int continuousEmptyMessage = 0;
             string errorMessage = string.Empty;
             Stopwatch heartbeat = new();
             heartbeat.Restart();
@@ -260,28 +228,6 @@ namespace GitHub.Runner.Listener
                     // Decrypt the message body if the session is using encryption
                     message = DecryptMessage(message);
 
-                    if (message != null && message.MessageType == BrokerMigrationMessage.MessageType)
-                    {
-                        var migrationMessage = JsonUtility.FromString<BrokerMigrationMessage>(message.Body);
-
-                        _credsV2 = _credMgr.LoadCredentials(allowAuthUrlV2: true);
-                        await _brokerServer.UpdateConnectionIfNeeded(migrationMessage.BrokerBaseUrl, _credsV2);
-                        if (_needRefreshCredsV2)
-                        {
-                            Trace.Info("Refreshing credentials for V2.");
-                            await _brokerServer.ForceRefreshConnection(_credsV2);
-                            _needRefreshCredsV2 = false;
-                        }
-
-                        message = await _brokerServer.GetRunnerMessageAsync(_session.SessionId,
-                                                                        runnerStatus,
-                                                                        BuildConstants.RunnerPackage.Version,
-                                                                        VarUtil.OS,
-                                                                        VarUtil.OSArchitecture,
-                                                                        _settings.DisableUpdate,
-                                                                        token);
-                    }
-
                     if (message != null)
                     {
                         _lastMessageId = message.MessageId;
@@ -310,16 +256,7 @@ namespace GitHub.Runner.Listener
                     _accessTokenRevoked = true;
                     throw;
                 }
-                catch (HostedRunnerDeprovisionedException)
-                {
-                    Trace.Info("Hosted runner has been deprovisioned.");
-                    throw;
-                }
-                catch (AccessDeniedException e) when (e.ErrorCode == 1 && !HostContext.AllowAuthMigration)
-                {
-                    throw;
-                }
-                catch (RunnerNotFoundException) when (!HostContext.AllowAuthMigration)
+                catch (AccessDeniedException e) when (e.ErrorCode == 1)
                 {
                     throw;
                 }
@@ -328,19 +265,12 @@ namespace GitHub.Runner.Listener
                     Trace.Error("Catch exception during get next message.");
                     Trace.Error(ex);
 
-                    // clear out potential message for broker migration,
-                    // in case the exception is thrown from get message from broker-listener.
-                    message = null;
-
                     // don't retry if SkipSessionRecover = true, DT service will delete agent session to stop agent from taking more jobs.
-                    if (!HostContext.AllowAuthMigration &&
-                        ex is TaskAgentSessionExpiredException &&
-                        !_settings.SkipSessionRecover && (await CreateSessionAsync(token) == CreateSessionResult.Success))
+                    if (ex is TaskAgentSessionExpiredException && !_settings.SkipSessionRecover && await CreateSessionAsync(token))
                     {
                         Trace.Info($"{nameof(TaskAgentSessionExpiredException)} received, recovered by recreate session.");
                     }
-                    else if (!HostContext.AllowAuthMigration &&
-                            !IsGetNextMessageExceptionRetriable(ex))
+                    else if (!IsGetNextMessageExceptionRetriable(ex))
                     {
                         throw;
                     }
@@ -367,12 +297,6 @@ namespace GitHub.Runner.Listener
                             encounteringError = true;
                         }
 
-                        if (HostContext.AllowAuthMigration)
-                        {
-                            Trace.Info("Disable migration mode for 60 minutes.");
-                            HostContext.DeferAuthMigration(TimeSpan.FromMinutes(60), $"Get next message failed with exception: {ex}");
-                        }
-
                         // re-create VssConnection before next retry
                         await _runnerServer.RefreshConnectionAsync(RunnerConnectionType.MessageQueue, TimeSpan.FromSeconds(60));
 
@@ -387,27 +311,16 @@ namespace GitHub.Runner.Listener
 
                 if (message == null)
                 {
-                    continuousEmptyMessage++;
                     if (heartbeat.Elapsed > TimeSpan.FromMinutes(30))
                     {
                         Trace.Info($"No message retrieved from session '{_session.SessionId}' within last 30 minutes.");
                         heartbeat.Restart();
-                        continuousEmptyMessage = 0;
                     }
                     else
                     {
                         Trace.Verbose($"No message retrieved from session '{_session.SessionId}'.");
                     }
 
-                    if (continuousEmptyMessage > 50)
-                    {
-                        // retried more than 50 times in less than 30mins and still getting empty message
-                        // something is not right on the service side, backoff for 15-30s before retry
-                        _getNextMessageRetryInterval = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(30), _getNextMessageRetryInterval);
-                        Trace.Info("Sleeping for {0} seconds before retrying.", _getNextMessageRetryInterval.TotalSeconds);
-                        await HostContext.Delay(_getNextMessageRetryInterval, token);
-                    }
-
                     continue;
                 }
 
@@ -430,13 +343,6 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        public async Task RefreshListenerTokenAsync()
-        {
-            await _runnerServer.RefreshConnectionAsync(RunnerConnectionType.MessageQueue, TimeSpan.FromSeconds(60));
-            _credsV2 = _credMgr.LoadCredentials(allowAuthUrlV2: true);
-            await _brokerServer.ForceRefreshConnection(_credsV2);
-        }
-
         private TaskAgentMessage DecryptMessage(TaskAgentMessage message)
         {
             if (_session.EncryptionKey == null ||
@@ -486,7 +392,6 @@ namespace GitHub.Runner.Listener
                 ex is TaskAgentPoolNotFoundException ||
                 ex is TaskAgentSessionExpiredException ||
                 ex is AccessDeniedException ||
-                ex is RunnerNotFoundException ||
                 ex is VssUnauthorizedException)
             {
                 Trace.Info($"Non-retriable exception: {ex.Message}");
@@ -553,8 +458,7 @@ namespace GitHub.Runner.Listener
             }
             else if (ex is TaskAgentPoolNotFoundException ||
                      ex is AccessDeniedException ||
-                     ex is VssUnauthorizedException ||
-                     (ex is VssOAuthTokenRequestException oauthEx && oauthEx.Error != "server_error"))
+                     ex is VssUnauthorizedException)
             {
                 Trace.Info($"Non-retriable exception: {ex.Message}");
                 return false;
@@ -565,11 +469,5 @@ namespace GitHub.Runner.Listener
                 return true;
             }
         }
-
-        private void HandleAuthMigrationChanged(object sender, EventArgs e)
-        {
-            Trace.Info($"Auth migration changed. Current allow auth migration state: {HostContext.AllowAuthMigration}");
-            _needRefreshCredsV2 = true;
-        }
     }
 }

src/Runner.Listener/Program.cs

@@ -7,7 +7,6 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.WebApi;
-using GitHub.Services.WebApi;
 
 namespace GitHub.Runner.Listener
 {
@@ -145,12 +144,6 @@ namespace GitHub.Runner.Listener
                 trace.Error(e);
                 return Constants.Runner.ReturnCode.TerminatedError;
             }
-            catch (RunnerNotFoundException e)
-            {
-                terminal.WriteError($"An error occurred: {e.Message}");
-                trace.Error(e);
-                return Constants.Runner.ReturnCode.TerminatedError;
-            }
             catch (Exception e)
             {
                 terminal.WriteError($"An error occurred: {e.Message}");

src/Runner.Listener/Runner.Listener.csproj

@@ -1,12 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <RuntimeIdentifiers>win-x64;win-x86;linux-x64;linux-arm64;linux-arm;osx-x64;osx-arm64;win-arm64</RuntimeIdentifiers>
-    <SelfContained>true</SelfContained>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
-    <NoWarn>NU1701;NU1603;SYSLIB0050;SYSLIB0051</NoWarn>
+    <NoWarn>NU1701;NU1603</NoWarn>
     <Version>$(Version)</Version>
     <PredefinedCulturesOnly>false</PredefinedCulturesOnly>
     <PublishReadyToRunComposite>true</PublishReadyToRunComposite>
@@ -19,11 +18,17 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.4.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="5.0.0" />
-    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="8.0.0" />
-    <PackageReference Include="System.ServiceProcess.ServiceController" Version="8.0.1" />
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="4.4.0" />
+    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="4.4.0" />
+    <PackageReference Include="System.ServiceProcess.ServiceController" Version="4.4.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="..\Misc\runnercoreassets">
+      <LogicalName>GitHub.Runner.Listener.runnercoreassets</LogicalName>
+    </EmbeddedResource>
   </ItemGroup>
 
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

src/Runner.Listener/Runner.cs

@@ -1,12 +1,10 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
-using System.Security.Claims;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -16,9 +14,7 @@ using GitHub.Runner.Common.Util;
 using GitHub.Runner.Listener.Check;
 using GitHub.Runner.Listener.Configuration;
 using GitHub.Runner.Sdk;
-using GitHub.Services.OAuth;
 using GitHub.Services.WebApi;
-using GitHub.Services.WebApi.Jwt;
 using Pipelines = GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Listener
@@ -35,35 +31,11 @@ namespace GitHub.Runner.Listener
         private ITerminal _term;
         private bool _inConfigStage;
         private ManualResetEvent _completedCommand = new(false);
-        private readonly ConcurrentQueue<string> _authMigrationTelemetries = new();
-        private Task _authMigrationTelemetryTask;
-        private readonly object _authMigrationTelemetryLock = new();
-        private Task _authMigrationClaimsCheckTask;
-        private readonly object _authMigrationClaimsCheckLock = new();
-        private IRunnerServer _runnerServer;
-        private CancellationTokenSource _authMigrationTelemetryTokenSource = new();
-        private CancellationTokenSource _authMigrationClaimsCheckTokenSource = new();
-
-        // <summary>
-        // Helps avoid excessive calls to Run Service when encountering non-retriable errors from /acquirejob.
-        // Normally we rely on the HTTP clients to back off between retry attempts. However, acquiring a job
-        // involves calls to both Run Serivce and Broker. And Run Service and Broker communicate with each other
-        // in an async fashion.
-        //
-        // When Run Service encounters a non-retriable error, it sends an async message to Broker. The runner will,
-        // however, immediately call Broker to get the next message. If the async event from Run Service to Broker
-        // has not yet been processed, the next message from Broker may be the same job message.
-        //
-        // The error throttler helps us back off when encountering successive, non-retriable errors from /acquirejob.
-        // </summary>
-        private IErrorThrottler _acquireJobThrottler;
 
         public override void Initialize(IHostContext hostContext)
         {
             base.Initialize(hostContext);
             _term = HostContext.GetService<ITerminal>();
-            _acquireJobThrottler = HostContext.CreateService<IErrorThrottler>();
-            _runnerServer = HostContext.GetService<IRunnerServer>();
         }
 
         public async Task<int> ExecuteCommand(CommandSettings command)
@@ -79,8 +51,6 @@ namespace GitHub.Runner.Listener
                 //register a SIGTERM handler
                 HostContext.Unloading += Runner_Unloading;
 
-                HostContext.AuthMigrationChanged += HandleAuthMigrationChanged;
-
                 // TODO Unit test to cover this logic
                 Trace.Info(nameof(ExecuteCommand));
                 var configManager = HostContext.GetService<IConfigurationManager>();
@@ -243,21 +213,15 @@ namespace GitHub.Runner.Listener
                             var configFile = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Root), config.Key);
                             var configContent = Convert.FromBase64String(config.Value);
 #if OS_WINDOWS
-#pragma warning disable CA1416
                             if (configFile == HostContext.GetConfigFile(WellKnownConfigFile.RSACredentials))
                             {
                                 configContent = ProtectedData.Protect(configContent, null, DataProtectionScope.LocalMachine);
                             }
-#pragma warning restore CA1416
 #endif
                             File.WriteAllBytes(configFile, configContent);
                             File.SetAttributes(configFile, File.GetAttributes(configFile) | FileAttributes.Hidden);
                             Trace.Info($"Saved {configContent.Length} bytes to '{configFile}'.");
                         }
-
-                        // make sure we have the right user agent data added from the jitconfig
-                        HostContext.LoadDefaultUserAgents();
-                        VssUtil.InitializeVssClientSettings(HostContext.UserAgents, HostContext.WebProxy);
                     }
                     catch (Exception ex)
                     {
@@ -315,17 +279,8 @@ namespace GitHub.Runner.Listener
                         _term.WriteLine("https://docs.github.com/en/actions/hosting-your-own-runners/autoscaling-with-self-hosted-runners#using-ephemeral-runners-for-autoscaling", ConsoleColor.Yellow);
                     }
 
-                    var cred = store.GetCredentials();
-                    if (cred != null &&
-                        cred.Scheme == Constants.Configuration.OAuth &&
-                        cred.Data.ContainsKey("EnableAuthMigrationByDefault"))
-                    {
-                        Trace.Info("Enable auth migration by default.");
-                        HostContext.EnableAuthMigration("EnableAuthMigrationByDefault");
-                    }
-
                     // Run the runner interactively or as service
-                    return await ExecuteRunnerAsync(settings, command.RunOnce || settings.Ephemeral);
+                    return await RunAsync(settings, command.RunOnce || settings.Ephemeral);
                 }
                 else
                 {
@@ -335,9 +290,6 @@ namespace GitHub.Runner.Listener
             }
             finally
             {
-                _authMigrationClaimsCheckTokenSource?.Cancel();
-                _authMigrationTelemetryTokenSource?.Cancel();
-                HostContext.AuthMigrationChanged -= HandleAuthMigrationChanged;
                 _term.CancelKeyPress -= CtrlCHandler;
                 HostContext.Unloading -= Runner_Unloading;
                 _completedCommand.Set();
@@ -387,12 +339,12 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private IMessageListener GetMessageListener(RunnerSettings settings, bool isMigratedSettings = false)
+        private IMessageListener GetMesageListener(RunnerSettings settings)
         {
             if (settings.UseV2Flow)
             {
                 Trace.Info($"Using BrokerMessageListener");
-                var brokerListener = new BrokerMessageListener(settings, isMigratedSettings);
+                var brokerListener = new BrokerMessageListener();
                 brokerListener.Initialize(HostContext);
                 return brokerListener;
             }
@@ -406,65 +358,10 @@ namespace GitHub.Runner.Listener
             try
             {
                 Trace.Info(nameof(RunAsync));
-                
-                // First try using migrated settings if available
-                var configManager = HostContext.GetService<IConfigurationManager>();
-                RunnerSettings migratedSettings = null;
-                
-                try 
+                _listener = GetMesageListener(settings);
+                if (!await _listener.CreateSessionAsync(HostContext.RunnerShutdownToken))
                 {
-                    migratedSettings = configManager.LoadMigratedSettings();
-                    Trace.Info("Loaded migrated settings from .runner_migrated file");
-                    Trace.Info(migratedSettings);
-                }
-                catch (Exception ex)
-                {
-                    // If migrated settings file doesn't exist or can't be loaded, we'll use the provided settings
-                    Trace.Info($"Failed to load migrated settings: {ex.Message}");
-                }
-                
-                bool usedMigratedSettings = false;
-                
-                if (migratedSettings != null)
-                {
-                    // Try to create session with migrated settings first
-                    Trace.Info("Attempting to create session using migrated settings");
-                    _listener = GetMessageListener(migratedSettings, isMigratedSettings: true);
-                    
-                    try
-                    {
-                        CreateSessionResult createSessionResult = await _listener.CreateSessionAsync(HostContext.RunnerShutdownToken);
-                        if (createSessionResult == CreateSessionResult.Success)
-                        {
-                            Trace.Info("Successfully created session with migrated settings");
-                            settings = migratedSettings; // Use migrated settings for the rest of the process
-                            usedMigratedSettings = true;
-                        }
-                        else
-                        {
-                            Trace.Warning($"Failed to create session with migrated settings: {createSessionResult}");
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        Trace.Error($"Exception when creating session with migrated settings: {ex}");
-                    }
-                }
-                
-                // If migrated settings weren't used or session creation failed, use original settings
-                if (!usedMigratedSettings)
-                {
-                    Trace.Info("Falling back to original .runner settings");
-                    _listener = GetMessageListener(settings);
-                    CreateSessionResult createSessionResult = await _listener.CreateSessionAsync(HostContext.RunnerShutdownToken);
-                    if (createSessionResult == CreateSessionResult.SessionConflict)
-                    {
-                        return Constants.Runner.ReturnCode.SessionConflict;
-                    }
-                    else if (createSessionResult == CreateSessionResult.Failure)
-                    {
-                        return Constants.Runner.ReturnCode.TerminatedError;
-                    }
+                    return Constants.Runner.ReturnCode.TerminatedError;
                 }
 
                 HostContext.WritePerfCounter("SessionCreated");
@@ -478,8 +375,6 @@ namespace GitHub.Runner.Listener
                 // Should we try to cleanup ephemeral runners
                 bool runOnceJobCompleted = false;
                 bool skipSessionDeletion = false;
-                bool restartSession = false; // Flag to indicate session restart
-                bool restartSessionPending = false;
                 try
                 {
                     var notification = HostContext.GetService<IJobNotification>();
@@ -495,15 +390,6 @@ namespace GitHub.Runner.Listener
 
                     while (!HostContext.RunnerShutdownToken.IsCancellationRequested)
                     {
-                        // Check if we need to restart the session and can do so (job dispatcher not busy)
-                        if (restartSessionPending && !jobDispatcher.Busy)
-                        {
-                            Trace.Info("Pending session restart detected and job dispatcher is not busy. Restarting session now.");
-                            messageQueueLoopTokenSource.Cancel();
-                            restartSession = true;
-                            break;
-                        }
-                        
                         TaskAgentMessage message = null;
                         bool skipMessageDeletion = false;
                         try
@@ -658,42 +544,27 @@ namespace GitHub.Runner.Listener
 
                                     // Create connection
                                     var credMgr = HostContext.GetService<ICredentialManager>();
+                                    var creds = credMgr.LoadCredentials();
+
                                     if (string.IsNullOrEmpty(messageRef.RunServiceUrl))
                                     {
-                                        var creds = credMgr.LoadCredentials(allowAuthUrlV2: false);
                                         var actionsRunServer = HostContext.CreateService<IActionsRunServer>();
                                         await actionsRunServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
                                         jobRequestMessage = await actionsRunServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
                                     }
                                     else
                                     {
-                                        var credsV2 = credMgr.LoadCredentials(allowAuthUrlV2: true);
                                         var runServer = HostContext.CreateService<IRunServer>();
-                                        await runServer.ConnectAsync(new Uri(messageRef.RunServiceUrl), credsV2);
+                                        await runServer.ConnectAsync(new Uri(messageRef.RunServiceUrl), creds);
                                         try
                                         {
-                                            jobRequestMessage = await runServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageRef.BillingOwnerId, messageQueueLoopTokenSource.Token);
-                                            _acquireJobThrottler.Reset();
+                                            jobRequestMessage =
+                                            await runServer.GetJobMessageAsync(messageRef.RunnerRequestId,
+                                            messageQueueLoopTokenSource.Token);
                                         }
-                                        catch (Exception ex) when (
-                                            ex is TaskOrchestrationJobNotFoundException ||          // HTTP status 404
-                                            ex is TaskOrchestrationJobAlreadyAcquiredException ||   // HTTP status 409
-                                            ex is TaskOrchestrationJobUnprocessableException)       // HTTP status 422
+                                        catch (TaskOrchestrationJobAlreadyAcquiredException)
                                         {
-                                            Trace.Info($"Skipping message Job. {ex.Message}");
-                                            await _acquireJobThrottler.IncrementAndWaitAsync(messageQueueLoopTokenSource.Token);
-                                            continue;
-                                        }
-                                        catch (Exception ex)
-                                        {
-                                            Trace.Error($"Caught exception from acquiring job message: {ex}");
-
-                                            if (HostContext.AllowAuthMigration)
-                                            {
-                                                Trace.Info("Disable migration mode for 60 minutes.");
-                                                HostContext.DeferAuthMigration(TimeSpan.FromMinutes(60), $"Acquire job failed with exception: {ex}");
-                                            }
-
+                                            Trace.Info("Job is already acquired, skip this message.");
                                             continue;
                                         }
                                     }
@@ -725,33 +596,6 @@ namespace GitHub.Runner.Listener
                                 Trace.Info($"Service requests the hosted runner to shutdown. Reason: '{HostedRunnerShutdownMessage.Reason}'.");
                                 return Constants.Runner.ReturnCode.Success;
                             }
-                            else if (string.Equals(message.MessageType, TaskAgentMessageTypes.ForceTokenRefresh))
-                            {
-                                Trace.Info("Received ForceTokenRefreshMessage");
-                                await _listener.RefreshListenerTokenAsync();
-                            }
-                            else if (string.Equals(message.MessageType, RunnerRefreshConfigMessage.MessageType))
-                            {
-                                var runnerRefreshConfigMessage = JsonUtility.FromString<RunnerRefreshConfigMessage>(message.Body);
-                                Trace.Info($"Received RunnerRefreshConfigMessage for '{runnerRefreshConfigMessage.ConfigType}' config file");
-                                var configUpdater = HostContext.GetService<IRunnerConfigUpdater>();
-                                await configUpdater.UpdateRunnerConfigAsync(
-                                    runnerQualifiedId: runnerRefreshConfigMessage.RunnerQualifiedId,
-                                    configType: runnerRefreshConfigMessage.ConfigType,
-                                    serviceType: runnerRefreshConfigMessage.ServiceType,
-                                    configRefreshUrl: runnerRefreshConfigMessage.ConfigRefreshUrl);
-
-                                // Set flag to schedule session restart if ConfigType is "runner"
-                                if (string.Equals(runnerRefreshConfigMessage.ConfigType, "runner", StringComparison.OrdinalIgnoreCase))
-                                {
-                                    Trace.Info("Runner configuration was updated. Session restart has been scheduled");
-                                    restartSessionPending = true;
-                                }
-                                else
-                                {
-                                    Trace.Info($"No session restart needed for config type: {runnerRefreshConfigMessage.ConfigType}");
-                                }
-                            }
                             else
                             {
                                 Trace.Error($"Received message {message.MessageId} with unsupported message type {message.MessageType}.");
@@ -790,7 +634,6 @@ namespace GitHub.Runner.Listener
                     {
                         try
                         {
-                            Trace.Info("Deleting Runner Session...");
                             await _listener.DeleteSessionAsync();
                         }
                         catch (Exception ex) when (runOnce)
@@ -805,243 +648,19 @@ namespace GitHub.Runner.Listener
 
                     if (settings.Ephemeral && runOnceJobCompleted)
                     {
+                        var configManager = HostContext.GetService<IConfigurationManager>();
                         configManager.DeleteLocalRunnerConfig();
                     }
                 }
-
-                // After cleanup, check if we need to restart the session
-                if (restartSession)
-                {
-                    Trace.Info("Restarting runner session after config update...");
-                    return Constants.Runner.ReturnCode.RunnerConfigurationRefreshed;
-                }
             }
             catch (TaskAgentAccessTokenExpiredException)
             {
                 Trace.Info("Runner OAuth token has been revoked. Shutting down.");
             }
-            catch (HostedRunnerDeprovisionedException)
-            {
-                Trace.Info("Hosted runner has been deprovisioned. Shutting down.");
-            }
 
             return Constants.Runner.ReturnCode.Success;
         }
 
-        private async Task<int> ExecuteRunnerAsync(RunnerSettings settings, bool runOnce)
-        {
-            int returnCode = Constants.Runner.ReturnCode.Success;
-            bool restart = false;
-            do
-            {
-                restart = false;
-                returnCode = await RunAsync(settings, runOnce);
-                
-                if (returnCode == Constants.Runner.ReturnCode.RunnerConfigurationRefreshed)
-                {
-                    Trace.Info("Runner configuration was refreshed, restarting session...");
-                    // Reload settings in case they changed
-                    var configManager = HostContext.GetService<IConfigurationManager>();
-                    settings = configManager.LoadSettings();
-                    restart = true;
-                }
-            } while (restart);
-
-            return returnCode;
-        }
-
-        private void HandleAuthMigrationChanged(object sender, AuthMigrationEventArgs e)
-        {
-            Trace.Verbose("Handle AuthMigrationChanged in Runner");
-            _authMigrationTelemetries.Enqueue($"{DateTime.UtcNow.ToString("O")}: {e.Trace}");
-
-            // only start the telemetry reporting task once auth migration is changed (enabled or disabled)
-            lock (_authMigrationTelemetryLock)
-            {
-                if (_authMigrationTelemetryTask == null)
-                {
-                    _authMigrationTelemetryTask = ReportAuthMigrationTelemetryAsync(_authMigrationTelemetryTokenSource.Token);
-                }
-            }
-
-            // only start the claims check task once auth migration is changed (enabled or disabled)
-            lock (_authMigrationClaimsCheckLock)
-            {
-                if (_authMigrationClaimsCheckTask == null)
-                {
-                    _authMigrationClaimsCheckTask = CheckOAuthTokenClaimsAsync(_authMigrationClaimsCheckTokenSource.Token);
-                }
-            }
-        }
-
-        private async Task CheckOAuthTokenClaimsAsync(CancellationToken token)
-        {
-            string[] expectedClaims =
-            [
-                "owner_id",
-                "runner_id",
-                "runner_group_id",
-                "scale_set_id",
-                "is_ephemeral",
-                "labels"
-            ];
-
-            try
-            {
-                var credMgr = HostContext.GetService<ICredentialManager>();
-                while (!token.IsCancellationRequested)
-                {
-                    try
-                    {
-                        await HostContext.Delay(TimeSpan.FromMinutes(100), token);
-                    }
-                    catch (TaskCanceledException)
-                    {
-                        // Ignore cancellation
-                    }
-
-                    if (token.IsCancellationRequested)
-                    {
-                        break;
-                    }
-
-                    if (!HostContext.AllowAuthMigration)
-                    {
-                        Trace.Info("Skip checking oauth token claims since auth migration is disabled.");
-                        continue;
-                    }
-
-                    var baselineCred = credMgr.LoadCredentials(allowAuthUrlV2: false);
-                    var authV2Cred = credMgr.LoadCredentials(allowAuthUrlV2: true);
-
-                    if (!(baselineCred.Federated is VssOAuthCredential baselineVssOAuthCred) ||
-                        !(authV2Cred.Federated is VssOAuthCredential vssOAuthCredV2) ||
-                        baselineVssOAuthCred == null ||
-                        vssOAuthCredV2 == null)
-                    {
-                        Trace.Info("Skip checking oauth token claims for non-oauth credentials");
-                        continue;
-                    }
-
-                    if (string.Equals(baselineVssOAuthCred.AuthorizationUrl.AbsoluteUri, vssOAuthCredV2.AuthorizationUrl.AbsoluteUri, StringComparison.OrdinalIgnoreCase))
-                    {
-                        Trace.Info("Skip checking oauth token claims for same authorization url");
-                        continue;
-                    }
-
-                    var baselineProvider = baselineVssOAuthCred.GetTokenProvider(baselineVssOAuthCred.AuthorizationUrl);
-                    var v2Provider = vssOAuthCredV2.GetTokenProvider(vssOAuthCredV2.AuthorizationUrl);
-                    try
-                    {
-                        using (var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
-                        using (var requestTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, timeoutTokenSource.Token))
-                        {
-                            var baselineToken = await baselineProvider.GetTokenAsync(null, requestTokenSource.Token);
-                            var v2Token = await v2Provider.GetTokenAsync(null, requestTokenSource.Token);
-                            if (baselineToken is VssOAuthAccessToken baselineAccessToken &&
-                                v2Token is VssOAuthAccessToken v2AccessToken &&
-                                !string.IsNullOrEmpty(baselineAccessToken.Value) &&
-                                !string.IsNullOrEmpty(v2AccessToken.Value))
-                            {
-                                var baselineJwt = JsonWebToken.Create(baselineAccessToken.Value);
-                                var baselineClaims = baselineJwt.ExtractClaims();
-                                var v2Jwt = JsonWebToken.Create(v2AccessToken.Value);
-                                var v2Claims = v2Jwt.ExtractClaims();
-
-                                // Log extracted claims for debugging
-                                Trace.Verbose($"Baseline token expected claims: {string.Join(", ", baselineClaims
-                                    .Where(c => expectedClaims.Contains(c.Type.ToLowerInvariant()))
-                                    .Select(c => $"{c.Type}:{c.Value}"))}");
-                                Trace.Verbose($"V2 token expected claims: {string.Join(", ", v2Claims
-                                    .Where(c => expectedClaims.Contains(c.Type.ToLowerInvariant()))
-                                    .Select(c => $"{c.Type}:{c.Value}"))}");
-
-                                foreach (var claim in expectedClaims)
-                                {
-                                    // if baseline has the claim, v2 should have it too with exactly same value.
-                                    if (baselineClaims.FirstOrDefault(c => c.Type.ToLowerInvariant() == claim) is Claim baselineClaim &&
-                                        !string.IsNullOrEmpty(baselineClaim?.Value))
-                                    {
-                                        var v2Claim = v2Claims.FirstOrDefault(c => c.Type.ToLowerInvariant() == claim);
-                                        if (v2Claim?.Value != baselineClaim.Value)
-                                        {
-                                            Trace.Info($"Token Claim mismatch between two issuers. Expected: {baselineClaim.Type}:{baselineClaim.Value}. Actual: {v2Claim?.Type ?? "Empty"}:{v2Claim?.Value ?? "Empty"}");
-                                            HostContext.DeferAuthMigration(TimeSpan.FromMinutes(60), $"Expected claim {baselineClaim.Type}:{baselineClaim.Value} does not match {v2Claim?.Type ?? "Empty"}:{v2Claim?.Value ?? "Empty"}");
-                                            break;
-                                        }
-                                    }
-                                }
-
-                                Trace.Info("OAuth token claims check passed.");
-                            }
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        Trace.Error("Failed to fetch and check OAuth token claims.");
-                        Trace.Error(ex);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Trace.Error("Failed to check OAuth token claims in background.");
-                Trace.Error(ex);
-            }
-        }
-
-        private async Task ReportAuthMigrationTelemetryAsync(CancellationToken token)
-        {
-            var configManager = HostContext.GetService<IConfigurationManager>();
-            var runnerSettings = configManager.LoadSettings();
-
-            while (!token.IsCancellationRequested)
-            {
-                try
-                {
-                    await HostContext.Delay(TimeSpan.FromSeconds(60), token);
-                }
-                catch (TaskCanceledException)
-                {
-                    // Ignore cancellation
-                }
-
-                Trace.Verbose("Checking for auth migration telemetry to report");
-                while (_authMigrationTelemetries.TryDequeue(out var telemetry))
-                {
-                    Trace.Verbose($"Reporting auth migration telemetry: {telemetry}");
-                    if (runnerSettings != null)
-                    {
-                        try
-                        {
-                            using (var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
-                            {
-                                await _runnerServer.UpdateAgentUpdateStateAsync(runnerSettings.PoolId, runnerSettings.AgentId, "RefreshConfig", telemetry, tokenSource.Token);
-                            }
-                        }
-                        catch (Exception ex)
-                        {
-                            Trace.Error("Failed to report auth migration telemetry.");
-                            Trace.Error(ex);
-                            _authMigrationTelemetries.Enqueue(telemetry);
-                        }
-                    }
-
-                    if (!token.IsCancellationRequested)
-                    {
-                        try
-                        {
-                            await HostContext.Delay(TimeSpan.FromSeconds(10), token);
-                        }
-                        catch (TaskCanceledException)
-                        {
-                            // Ignore cancellation
-                        }
-                    }
-                }
-            }
-        }
-
         private void PrintUsage(CommandSettings command)
         {
             string separator;

src/Runner.Listener/RunnerConfigUpdater.cs

@@ -1,287 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GitHub.Runner.Common;
-using GitHub.Runner.Sdk;
-using GitHub.Services.Common;
-
-namespace GitHub.Runner.Listener
-{
-    [ServiceLocator(Default = typeof(RunnerConfigUpdater))]
-    public interface IRunnerConfigUpdater : IRunnerService
-    {
-        Task UpdateRunnerConfigAsync(string runnerQualifiedId, string configType, string serviceType, string configRefreshUrl);
-    }
-
-    public sealed class RunnerConfigUpdater : RunnerService, IRunnerConfigUpdater
-    {
-        private RunnerSettings _settings;
-        private CredentialData _credData;
-        private IRunnerServer _runnerServer;
-        private IConfigurationStore _store;
-
-        public override void Initialize(IHostContext hostContext)
-        {
-            base.Initialize(hostContext);
-            _store = hostContext.GetService<IConfigurationStore>();
-            _settings = _store.GetSettings();
-            _credData = _store.GetCredentials();
-            _runnerServer = HostContext.GetService<IRunnerServer>();
-        }
-
-        public async Task UpdateRunnerConfigAsync(string runnerQualifiedId, string configType, string serviceType, string configRefreshUrl)
-        {
-            Trace.Entering();
-            try
-            {
-                ArgUtil.NotNullOrEmpty(runnerQualifiedId, nameof(runnerQualifiedId));
-                ArgUtil.NotNullOrEmpty(configType, nameof(configType));
-                ArgUtil.NotNullOrEmpty(serviceType, nameof(serviceType));
-                ArgUtil.NotNullOrEmpty(configRefreshUrl, nameof(configRefreshUrl));
-
-                // make sure the runner qualified id matches the current runner
-                if (!await VerifyRunnerQualifiedId(runnerQualifiedId))
-                {
-                    return;
-                }
-
-                // keep the timeout short to avoid blocking the main thread
-                using (var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
-                {
-                    switch (configType.ToLowerInvariant())
-                    {
-                        case "runner":
-                            await UpdateRunnerSettingsAsync(serviceType, configRefreshUrl, tokenSource.Token);
-                            break;
-                        case "credentials":
-                            await UpdateRunnerCredentialsAsync(serviceType, configRefreshUrl, tokenSource.Token);
-                            break;
-                        default:
-                            Trace.Error($"Invalid config type '{configType}'.");
-                            await ReportTelemetryAsync($"Invalid config type '{configType}'.");
-                            return;
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Trace.Error($"Failed to update runner '{configType}' config.");
-                Trace.Error(ex);
-                await ReportTelemetryAsync($"Failed to update runner '{configType}' config: {ex}");
-            }
-        }
-
-        private async Task UpdateRunnerSettingsAsync(string serviceType, string configRefreshUrl, CancellationToken token)
-        {
-            Trace.Entering();
-            // read the current runner settings and encode with base64
-            var runnerConfig = HostContext.GetConfigFile(WellKnownConfigFile.Runner);
-            string runnerConfigContent = File.ReadAllText(runnerConfig, Encoding.UTF8);
-            var encodedConfig = Convert.ToBase64String(Encoding.UTF8.GetBytes(runnerConfigContent));
-            if (string.IsNullOrEmpty(encodedConfig))
-            {
-                await ReportTelemetryAsync("Failed to get encoded runner settings.");
-                return;
-            }
-
-            // exchange the encoded runner settings with the service
-            string refreshedEncodedConfig = await RefreshRunnerConfigAsync(encodedConfig, serviceType, "runner", configRefreshUrl, token);
-            if (string.IsNullOrEmpty(refreshedEncodedConfig))
-            {
-                // service will return empty string if there is no change in the config
-                return;
-            }
-
-            var decodedConfig = Encoding.UTF8.GetString(Convert.FromBase64String(refreshedEncodedConfig));
-            RunnerSettings refreshedRunnerConfig;
-            try
-            {
-                refreshedRunnerConfig = StringUtil.ConvertFromJson<RunnerSettings>(decodedConfig);
-            }
-            catch (Exception ex)
-            {
-                Trace.Error($"Failed to convert runner config from json '{decodedConfig}'.");
-                Trace.Error(ex);
-                await ReportTelemetryAsync($"Failed to convert runner config '{decodedConfig}' from json: {ex}");
-                return;
-            }
-
-            // make sure the runner id and name in the refreshed config match the current runner
-            if (refreshedRunnerConfig?.AgentId != _settings.AgentId)
-            {
-                Trace.Error($"Runner id in refreshed config '{refreshedRunnerConfig?.AgentId.ToString() ?? "Empty"}' does not match the current runner '{_settings.AgentId}'.");
-                await ReportTelemetryAsync($"Runner id in refreshed config '{refreshedRunnerConfig?.AgentId.ToString() ?? "Empty"}' does not match the current runner '{_settings.AgentId}'.");
-                return;
-            }
-
-            if (refreshedRunnerConfig?.AgentName != _settings.AgentName)
-            {
-                Trace.Error($"Runner name in refreshed config '{refreshedRunnerConfig?.AgentName ?? "Empty"}' does not match the current runner '{_settings.AgentName}'.");
-                await ReportTelemetryAsync($"Runner name in refreshed config '{refreshedRunnerConfig?.AgentName ?? "Empty"}' does not match the current runner '{_settings.AgentName}'.");
-                return;
-            }
-
-            // save the refreshed runner settings as a separate file
-            _store.SaveMigratedSettings(refreshedRunnerConfig);
-            await ReportTelemetryAsync("Runner settings updated successfully.");
-        }
-
-        private async Task UpdateRunnerCredentialsAsync(string serviceType, string configRefreshUrl, CancellationToken token)
-        {
-            Trace.Entering();
-            // read the current runner credentials and encode with base64
-            var credConfig = HostContext.GetConfigFile(WellKnownConfigFile.Credentials);
-            string credConfigContent = File.ReadAllText(credConfig, Encoding.UTF8);
-            var encodedConfig = Convert.ToBase64String(Encoding.UTF8.GetBytes(credConfigContent));
-            if (string.IsNullOrEmpty(encodedConfig))
-            {
-                await ReportTelemetryAsync("Failed to get encoded credentials.");
-                return;
-            }
-
-            CredentialData currentCred = _store.GetCredentials();
-            if (currentCred == null)
-            {
-                await ReportTelemetryAsync("Failed to get current credentials.");
-                return;
-            }
-
-            // we only support refreshing OAuth credentials which is used by self-hosted runners.
-            if (currentCred.Scheme != Constants.Configuration.OAuth)
-            {
-                await ReportTelemetryAsync($"Not supported credential scheme '{currentCred.Scheme}'.");
-                return;
-            }
-
-            // exchange the encoded runner credentials with the service
-            string refreshedEncodedConfig = await RefreshRunnerConfigAsync(encodedConfig, serviceType, "credentials", configRefreshUrl, token);
-            if (string.IsNullOrEmpty(refreshedEncodedConfig))
-            {
-                // service will return empty string if there is no change in the config
-                return;
-            }
-
-            var decodedConfig = Encoding.UTF8.GetString(Convert.FromBase64String(refreshedEncodedConfig));
-            CredentialData refreshedCredConfig;
-            try
-            {
-                refreshedCredConfig = StringUtil.ConvertFromJson<CredentialData>(decodedConfig);
-            }
-            catch (Exception ex)
-            {
-                Trace.Error($"Failed to convert credentials config from json '{decodedConfig}'.");
-                Trace.Error(ex);
-                await ReportTelemetryAsync($"Failed to convert credentials config '{decodedConfig}' from json: {ex}");
-                return;
-            }
-
-            // make sure the credential scheme in the refreshed config match the current credential scheme
-            if (refreshedCredConfig?.Scheme != _credData.Scheme)
-            {
-                Trace.Error($"Credential scheme in refreshed config '{refreshedCredConfig?.Scheme ?? "Empty"}' does not match the current credential scheme '{_credData.Scheme}'.");
-                await ReportTelemetryAsync($"Credential scheme in refreshed config '{refreshedCredConfig?.Scheme ?? "Empty"}' does not match the current credential scheme '{_credData.Scheme}'.");
-                return;
-            }
-
-            if (_credData.Scheme == Constants.Configuration.OAuth)
-            {
-                // make sure the credential clientId in the refreshed config match the current credential clientId for OAuth auth scheme
-                var clientId = _credData.Data.GetValueOrDefault("clientId", null);
-                var refreshedClientId = refreshedCredConfig.Data.GetValueOrDefault("clientId", null);
-                if (clientId != refreshedClientId)
-                {
-                    Trace.Error($"Credential clientId in refreshed config '{refreshedClientId ?? "Empty"}' does not match the current credential clientId '{clientId}'.");
-                    await ReportTelemetryAsync($"Credential clientId in refreshed config '{refreshedClientId ?? "Empty"}' does not match the current credential clientId '{clientId}'.");
-                    return;
-                }
-
-                //  make sure the credential authorizationUrl in the refreshed config match the current credential authorizationUrl for OAuth auth scheme
-                var authorizationUrl = _credData.Data.GetValueOrDefault("authorizationUrl", null);
-                var refreshedAuthorizationUrl = refreshedCredConfig.Data.GetValueOrDefault("authorizationUrl", null);
-                if (authorizationUrl != refreshedAuthorizationUrl)
-                {
-                    Trace.Error($"Credential authorizationUrl in refreshed config '{refreshedAuthorizationUrl ?? "Empty"}' does not match the current credential authorizationUrl '{authorizationUrl}'.");
-                    await ReportTelemetryAsync($"Credential authorizationUrl in refreshed config '{refreshedAuthorizationUrl ?? "Empty"}' does not match the current credential authorizationUrl '{authorizationUrl}'.");
-                    return;
-                }
-            }
-
-            // save the refreshed runner credentials as a separate file
-            _store.SaveMigratedCredential(refreshedCredConfig);
-
-            if (refreshedCredConfig.Data.ContainsKey("authorizationUrlV2"))
-            {
-                HostContext.EnableAuthMigration("Credential file updated");
-                await ReportTelemetryAsync("Runner credentials updated successfully. Auth migration is enabled.");
-            }
-            else
-            {
-                HostContext.DeferAuthMigration(TimeSpan.FromDays(365), "Credential file does not contain authorizationUrlV2");
-                await ReportTelemetryAsync("Runner credentials updated successfully. Auth migration is disabled.");
-            }
-        }
-
-        private async Task<bool> VerifyRunnerQualifiedId(string runnerQualifiedId)
-        {
-            Trace.Entering();
-            Trace.Info($"Verifying runner qualified id: {runnerQualifiedId}");
-            var idParts = runnerQualifiedId.Split("/", StringSplitOptions.RemoveEmptyEntries);
-            if (idParts.Length != 4 || idParts[3] != _settings.AgentId.ToString())
-            {
-                Trace.Error($"Runner qualified id '{runnerQualifiedId}' does not match the current runner '{_settings.AgentId}'.");
-                await ReportTelemetryAsync($"Runner qualified id '{runnerQualifiedId}' does not match the current runner '{_settings.AgentId}'.");
-                return false;
-            }
-            return true;
-        }
-
-        private async Task<string> RefreshRunnerConfigAsync(string encodedConfig, string serviceType, string configType, string configRefreshUrl, CancellationToken token)
-        {
-            string refreshedEncodedConfig;
-            switch (serviceType.ToLowerInvariant())
-            {
-                case "pipelines":
-                    try
-                    {
-                        refreshedEncodedConfig = await _runnerServer.RefreshRunnerConfigAsync((int)_settings.AgentId, configType, encodedConfig, token);
-                    }
-                    catch (Exception ex)
-                    {
-                        Trace.Error($"Failed to refresh runner {configType} config with service.");
-                        Trace.Error(ex);
-                        await ReportTelemetryAsync($"Failed to refresh {configType} config: {ex}");
-                        return null;
-                    }
-                    break;
-                case "runner-admin":
-                    throw new NotSupportedException("Runner admin service is not supported.");
-                default:
-                    Trace.Error($"Invalid service type '{serviceType}'.");
-                    await ReportTelemetryAsync($"Invalid service type '{serviceType}'.");
-                    return null;
-            }
-
-            return refreshedEncodedConfig;
-        }
-
-        private async Task ReportTelemetryAsync(string telemetry)
-        {
-            Trace.Entering();
-            try
-            {
-                using (var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
-                {
-                    await _runnerServer.UpdateAgentUpdateStateAsync(_settings.PoolId, _settings.AgentId, "RefreshConfig", telemetry, tokenSource.Token);
-                }
-            }
-            catch (Exception ex)
-            {
-                Trace.Error("Failed to report telemetry.");
-                Trace.Error(ex);
-            }
-        }
-    }
-}

src/Runner.Listener/RunnerJobRequestRef.cs

@@ -7,14 +7,9 @@ namespace GitHub.Runner.Listener
     {
         [DataMember(Name = "id")]
         public string Id { get; set; }
-        
         [DataMember(Name = "runner_request_id")]
         public string RunnerRequestId { get; set; }
-        
         [DataMember(Name = "run_service_url")]
         public string RunServiceUrl { get; set; }
-        
-        [DataMember(Name = "billing_owner_id")]
-        public string BillingOwnerId { get; set; }
     }
 }

src/Runner.Listener/SelfUpdater.cs

@@ -6,11 +6,13 @@ using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using System.Net.Http;
+using System.Reflection;
 using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
+using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using GitHub.Services.WebApi;
@@ -28,14 +30,20 @@ namespace GitHub.Runner.Listener
     {
         private static string _packageType = "agent";
         private static string _platform = BuildConstants.RunnerPackage.PackageName;
+        private static string _dotnetRuntime = "dotnetRuntime";
+        private static string _externals = "externals";
+        private readonly Dictionary<string, string> _contentHashes = new();
 
         private PackageMetadata _targetPackage;
         private ITerminal _terminal;
         private IRunnerServer _runnerServer;
         private int _poolId;
         private ulong _agentId;
-        private const int _numberOfOldVersionsToKeep = 1;
         private readonly ConcurrentQueue<string> _updateTrace = new();
+        private Task _cloneAndCalculateContentHashTask;
+        private string _dotnetRuntimeCloneDirectory;
+        private string _externalsCloneDirectory;
+
         public bool Busy { get; private set; }
 
         public override void Initialize(IHostContext hostContext)
@@ -48,6 +56,8 @@ namespace GitHub.Runner.Listener
             var settings = configStore.GetSettings();
             _poolId = settings.PoolId;
             _agentId = settings.AgentId;
+            _dotnetRuntimeCloneDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), "__dotnet_runtime__");
+            _externalsCloneDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), "__externals__");
         }
 
         public async Task<bool> SelfUpdate(AgentRefreshMessage updateMessage, IJobDispatcher jobDispatcher, bool restartInteractiveRunner, CancellationToken token)
@@ -57,6 +67,13 @@ namespace GitHub.Runner.Listener
             {
                 var totalUpdateTime = Stopwatch.StartNew();
 
+                // Copy dotnet runtime and externals of current runner to a temp folder
+                // So we can re-use them with trimmed runner package, if possible.
+                // This process is best effort, if we can't use trimmed runner package, 
+                // we will just go with the full package.
+                var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
+                _cloneAndCalculateContentHashTask = CloneAndCalculateAssetsHash(_dotnetRuntimeCloneDirectory, _externalsCloneDirectory, linkedTokenSource.Token);
+
                 if (!await UpdateNeeded(updateMessage.TargetVersion, token))
                 {
                     Trace.Info($"Can't find available update package.");
@@ -70,6 +87,24 @@ namespace GitHub.Runner.Listener
                 await UpdateRunnerUpdateStateAsync("Runner update in progress, do not shutdown runner.");
                 await UpdateRunnerUpdateStateAsync($"Downloading {_targetPackage.Version} runner");
 
+                if (_targetPackage.TrimmedPackages?.Count > 0)
+                {
+                    // wait for cloning assets task to finish only if we have trimmed packages
+                    await _cloneAndCalculateContentHashTask;
+                }
+                else
+                {
+                    linkedTokenSource.Cancel();
+                    try
+                    {
+                        await _cloneAndCalculateContentHashTask;
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Info($"Ingore errors after cancelling cloning assets task: {ex}");
+                    }
+                }
+
                 await DownloadLatestRunner(token, updateMessage.TargetVersion);
                 Trace.Info($"Download latest runner and unzip into runner root.");
 
@@ -183,8 +218,54 @@ namespace GitHub.Runner.Listener
             string archiveFile = null;
             var packageDownloadUrl = _targetPackage.DownloadUrl;
             var packageHashValue = _targetPackage.HashValue;
+            var runtimeTrimmed = false;
+            var externalsTrimmed = false;
+            var fallbackToFullPackage = false;
+
+            // Only try trimmed package if sever sends them and we have calculated hash value of the current runtime/externals.
+            if (_contentHashes.Count == 2 &&
+                _contentHashes.ContainsKey(_dotnetRuntime) &&
+                _contentHashes.ContainsKey(_externals) &&
+                _targetPackage.TrimmedPackages?.Count > 0)
+            {
+                Trace.Info($"Current runner content hash: {StringUtil.ConvertToJson(_contentHashes)}");
+                Trace.Info($"Trimmed packages info from service: {StringUtil.ConvertToJson(_targetPackage.TrimmedPackages)}");
+                // Try to see whether we can use any size trimmed down package to speed up runner updates.
+                foreach (var trimmedPackage in _targetPackage.TrimmedPackages)
+                {
+                    if (trimmedPackage.TrimmedContents.Count == 2 &&
+                        trimmedPackage.TrimmedContents.TryGetValue(_dotnetRuntime, out var trimmedRuntimeHash) &&
+                        trimmedRuntimeHash == _contentHashes[_dotnetRuntime] &&
+                        trimmedPackage.TrimmedContents.TryGetValue(_externals, out var trimmedExternalsHash) &&
+                        trimmedExternalsHash == _contentHashes[_externals])
+                    {
+                        Trace.Info($"Use trimmed (runtime+externals) package '{trimmedPackage.DownloadUrl}' to update runner.");
+                        packageDownloadUrl = trimmedPackage.DownloadUrl;
+                        packageHashValue = trimmedPackage.HashValue;
+                        runtimeTrimmed = true;
+                        externalsTrimmed = true;
+                        break;
+                    }
+                    else if (trimmedPackage.TrimmedContents.Count == 1 &&
+                             trimmedPackage.TrimmedContents.TryGetValue(_externals, out trimmedExternalsHash) &&
+                             trimmedExternalsHash == _contentHashes[_externals])
+                    {
+                        Trace.Info($"Use trimmed (externals) package '{trimmedPackage.DownloadUrl}' to update runner.");
+                        packageDownloadUrl = trimmedPackage.DownloadUrl;
+                        packageHashValue = trimmedPackage.HashValue;
+                        externalsTrimmed = true;
+                        break;
+                    }
+                    else
+                    {
+                        Trace.Info($"Can't use trimmed package from '{trimmedPackage.DownloadUrl}' since the current runner does not carry those trimmed content (Hash mismatch).");
+                    }
+                }
+            }
 
             _updateTrace.Enqueue($"DownloadUrl: {packageDownloadUrl}");
+            _updateTrace.Enqueue($"RuntimeTrimmed: {runtimeTrimmed}");
+            _updateTrace.Enqueue($"ExternalsTrimmed: {externalsTrimmed}");
 
             try
             {
@@ -242,6 +323,12 @@ namespace GitHub.Runner.Listener
 
                 await ExtractRunnerPackage(archiveFile, latestRunnerDirectory, token);
             }
+            catch (Exception ex) when (runtimeTrimmed || externalsTrimmed)
+            {
+                // if anything failed when we use trimmed package (download/validatehase/extract), try again with the full runner package.
+                Trace.Error($"Fail to download latest runner using trimmed package: {ex}");
+                fallbackToFullPackage = true;
+            }
             finally
             {
                 try
@@ -260,6 +347,74 @@ namespace GitHub.Runner.Listener
                 }
             }
 
+            var trimmedPackageRestoreTasks = new List<Task<bool>>();
+            if (!fallbackToFullPackage)
+            {
+                // Skip restoring externals and runtime if we are going to fullback to the full package.
+                if (externalsTrimmed)
+                {
+                    trimmedPackageRestoreTasks.Add(RestoreTrimmedExternals(latestRunnerDirectory, token));
+                }
+                if (runtimeTrimmed)
+                {
+                    trimmedPackageRestoreTasks.Add(RestoreTrimmedDotnetRuntime(latestRunnerDirectory, token));
+                }
+            }
+
+            if (trimmedPackageRestoreTasks.Count > 0)
+            {
+                var restoreResults = await Task.WhenAll(trimmedPackageRestoreTasks);
+                if (restoreResults.Any(x => x == false))
+                {
+                    // if any of the restore failed, fallback to full package.
+                    fallbackToFullPackage = true;
+                }
+            }
+
+            if (fallbackToFullPackage)
+            {
+                Trace.Error("Something wrong with the trimmed runner package, failback to use the full package for runner updates.");
+                _updateTrace.Enqueue($"FallbackToFullPackage: {fallbackToFullPackage}");
+
+                IOUtil.DeleteDirectory(latestRunnerDirectory, token);
+                Directory.CreateDirectory(latestRunnerDirectory);
+
+                packageDownloadUrl = _targetPackage.DownloadUrl;
+                packageHashValue = _targetPackage.HashValue;
+                _updateTrace.Enqueue($"DownloadUrl: {packageDownloadUrl}");
+
+                try
+                {
+                    archiveFile = await DownLoadRunner(latestRunnerDirectory, packageDownloadUrl, packageHashValue, token);
+
+                    if (string.IsNullOrEmpty(archiveFile))
+                    {
+                        throw new TaskCanceledException($"Runner package '{packageDownloadUrl}' failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts");
+                    }
+
+                    await ValidateRunnerHash(archiveFile, packageHashValue);
+
+                    await ExtractRunnerPackage(archiveFile, latestRunnerDirectory, token);
+                }
+                finally
+                {
+                    try
+                    {
+                        // delete .zip file
+                        if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile))
+                        {
+                            Trace.Verbose("Deleting latest runner package zip: {0}", archiveFile);
+                            IOUtil.DeleteFile(archiveFile);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        //it is not critical if we fail to delete the .zip file
+                        Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex);
+                    }
+                }
+            }
+
             await CopyLatestRunnerToRoot(latestRunnerDirectory, token);
         }
 
@@ -510,9 +665,9 @@ namespace GitHub.Runner.Listener
 
             // delete old bin.2.99.0 folder, only leave the current version and the latest download version
             var allBinDirs = Directory.GetDirectories(HostContext.GetDirectory(WellKnownDirectory.Root), "bin.*");
-            if (allBinDirs.Length > _numberOfOldVersionsToKeep)
+            if (allBinDirs.Length > 2)
             {
-                // there are more than one bin.version folder.
+                // there are more than 2 bin.version folder.
                 // delete older bin.version folders.
                 foreach (var oldBinDir in allBinDirs)
                 {
@@ -539,9 +694,9 @@ namespace GitHub.Runner.Listener
 
             // delete old externals.2.99.0 folder, only leave the current version and the latest download version
             var allExternalsDirs = Directory.GetDirectories(HostContext.GetDirectory(WellKnownDirectory.Root), "externals.*");
-            if (allExternalsDirs.Length > _numberOfOldVersionsToKeep)
+            if (allExternalsDirs.Length > 2)
             {
-                // there are more than one externals.version folder.
+                // there are more than 2 externals.version folder.
                 // delete older externals.version folders.
                 foreach (var oldExternalDir in allExternalsDirs)
                 {
@@ -640,5 +795,330 @@ namespace GitHub.Runner.Listener
                 Trace.Info($"Catch exception during report update state, ignore this error and continue auto-update.");
             }
         }
+
+        private async Task<bool> RestoreTrimmedExternals(string downloadDirectory, CancellationToken token)
+        {
+            // Copy the current runner's externals if we are using a externals trimmed package
+            // Execute the node.js to make sure the copied externals is working.
+            var stopWatch = Stopwatch.StartNew();
+            try
+            {
+                Trace.Info($"Copy {_externalsCloneDirectory} to {Path.Combine(downloadDirectory, Constants.Path.ExternalsDirectory)}.");
+                IOUtil.CopyDirectory(_externalsCloneDirectory, Path.Combine(downloadDirectory, Constants.Path.ExternalsDirectory), token);
+
+                // try run node.js to see if current node.js works fine after copy over to new location.
+                var nodeVersions = NodeUtil.BuiltInNodeVersions;
+                foreach (var nodeVersion in nodeVersions)
+                {
+                    var newNodeBinary = Path.Combine(downloadDirectory, Constants.Path.ExternalsDirectory, nodeVersion, "bin", $"node{IOUtil.ExeExtension}");
+                    if (File.Exists(newNodeBinary))
+                    {
+                        using (var p = HostContext.CreateService<IProcessInvoker>())
+                        {
+                            var outputs = "";
+                            p.ErrorDataReceived += (_, data) =>
+                            {
+                                if (!string.IsNullOrEmpty(data.Data))
+                                {
+                                    Trace.Error(data.Data);
+                                }
+                            };
+                            p.OutputDataReceived += (_, data) =>
+                            {
+                                if (!string.IsNullOrEmpty(data.Data))
+                                {
+                                    Trace.Info(data.Data);
+                                    outputs = data.Data;
+                                }
+                            };
+                            var exitCode = await p.ExecuteAsync(HostContext.GetDirectory(WellKnownDirectory.Root), newNodeBinary, $"-e \"console.log('{nameof(RestoreTrimmedExternals)}')\"", null, token);
+                            if (exitCode != 0)
+                            {
+                                Trace.Error($"{newNodeBinary} -e \"console.log()\" failed with exit code {exitCode}");
+                                return false;
+                            }
+
+                            if (!string.Equals(outputs, nameof(RestoreTrimmedExternals), StringComparison.OrdinalIgnoreCase))
+                            {
+                                Trace.Error($"{newNodeBinary} -e \"console.log()\" did not output expected content.");
+                                return false;
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to restore externals for trimmed package: {ex}");
+                return false;
+            }
+            finally
+            {
+                stopWatch.Stop();
+                _updateTrace.Enqueue($"{nameof(RestoreTrimmedExternals)}Time: {stopWatch.ElapsedMilliseconds}ms");
+            }
+        }
+
+        private async Task<bool> RestoreTrimmedDotnetRuntime(string downloadDirectory, CancellationToken token)
+        {
+            // Copy the current runner's dotnet runtime if we are using a dotnet runtime trimmed package
+            // Execute the runner.listener to make sure the copied runtime is working.
+            var stopWatch = Stopwatch.StartNew();
+            try
+            {
+                Trace.Info($"Copy {_dotnetRuntimeCloneDirectory} to {Path.Combine(downloadDirectory, Constants.Path.BinDirectory)}.");
+                IOUtil.CopyDirectory(_dotnetRuntimeCloneDirectory, Path.Combine(downloadDirectory, Constants.Path.BinDirectory), token);
+
+                // try run the runner executable to see if current dotnet runtime + future runner binary works fine.
+                var newRunnerBinary = Path.Combine(downloadDirectory, Constants.Path.BinDirectory, "Runner.Listener");
+                using (var p = HostContext.CreateService<IProcessInvoker>())
+                {
+                    p.ErrorDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Error(data.Data);
+                        }
+                    };
+                    p.OutputDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Info(data.Data);
+                        }
+                    };
+                    var exitCode = await p.ExecuteAsync(HostContext.GetDirectory(WellKnownDirectory.Root), newRunnerBinary, "--version", null, token);
+                    if (exitCode != 0)
+                    {
+                        Trace.Error($"{newRunnerBinary} --version failed with exit code {exitCode}");
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to restore dotnet runtime for trimmed package: {ex}");
+                return false;
+            }
+            finally
+            {
+                stopWatch.Stop();
+                _updateTrace.Enqueue($"{nameof(RestoreTrimmedDotnetRuntime)}Time: {stopWatch.ElapsedMilliseconds}ms");
+            }
+        }
+
+        private async Task CloneAndCalculateAssetsHash(string dotnetRuntimeCloneDirectory, string externalsCloneDirectory, CancellationToken token)
+        {
+            var runtimeCloneTask = CloneDotnetRuntime(dotnetRuntimeCloneDirectory, token);
+            var externalsCloneTask = CloneExternals(externalsCloneDirectory, token);
+
+            var waitingTasks = new Dictionary<string, Task>()
+            {
+                {nameof(CloneDotnetRuntime), runtimeCloneTask},
+                {nameof(CloneExternals),externalsCloneTask}
+            };
+
+            while (waitingTasks.Count > 0)
+            {
+                Trace.Info($"Waiting for {waitingTasks.Count} tasks to complete.");
+                var complatedTask = await Task.WhenAny(waitingTasks.Values);
+                if (waitingTasks.ContainsKey(nameof(CloneExternals)) &&
+                    complatedTask == waitingTasks[nameof(CloneExternals)])
+                {
+                    Trace.Info($"Externals clone finished.");
+                    waitingTasks.Remove(nameof(CloneExternals));
+                    try
+                    {
+                        if (await externalsCloneTask && !token.IsCancellationRequested)
+                        {
+                            var externalsHash = await HashFiles(externalsCloneDirectory, token);
+                            Trace.Info($"Externals content hash: {externalsHash}");
+                            _contentHashes[_externals] = externalsHash;
+                            _updateTrace.Enqueue($"ExternalsHash: {_contentHashes[_externals]}");
+                        }
+                        else
+                        {
+                            Trace.Error($"Skip compute hash since clone externals failed/cancelled.");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Error($"Fail to hash externals content: {ex}");
+                    }
+                }
+                else if (waitingTasks.ContainsKey(nameof(CloneDotnetRuntime)) &&
+                         complatedTask == waitingTasks[nameof(CloneDotnetRuntime)])
+                {
+                    Trace.Info($"Dotnet runtime clone finished.");
+                    waitingTasks.Remove(nameof(CloneDotnetRuntime));
+                    try
+                    {
+                        if (await runtimeCloneTask && !token.IsCancellationRequested)
+                        {
+                            var runtimeHash = await HashFiles(dotnetRuntimeCloneDirectory, token);
+                            Trace.Info($"Runtime content hash: {runtimeHash}");
+                            _contentHashes[_dotnetRuntime] = runtimeHash;
+                            _updateTrace.Enqueue($"DotnetRuntimeHash: {_contentHashes[_dotnetRuntime]}");
+                        }
+                        else
+                        {
+                            Trace.Error($"Skip compute hash since clone dotnet runtime failed/cancelled.");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Error($"Fail to hash runtime content: {ex}");
+                    }
+                }
+
+                Trace.Info($"Still waiting for {waitingTasks.Count} tasks to complete.");
+            }
+        }
+
+        private async Task<bool> CloneDotnetRuntime(string runtimeDir, CancellationToken token)
+        {
+            var stopWatch = Stopwatch.StartNew();
+            try
+            {
+                Trace.Info($"Cloning dotnet runtime to {runtimeDir}");
+                IOUtil.DeleteDirectory(runtimeDir, CancellationToken.None);
+                Directory.CreateDirectory(runtimeDir);
+
+                var assembly = Assembly.GetExecutingAssembly();
+                var assetsContent = default(string);
+                using (var stream = assembly.GetManifestResourceStream("GitHub.Runner.Listener.runnercoreassets"))
+                using (var streamReader = new StreamReader(stream))
+                {
+                    assetsContent = await streamReader.ReadToEndAsync();
+                }
+
+                if (!string.IsNullOrEmpty(assetsContent))
+                {
+                    var runnerCoreAssets = assetsContent.Split(new[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
+                    if (runnerCoreAssets.Length > 0)
+                    {
+                        var binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
+                        IOUtil.CopyDirectory(binDir, runtimeDir, token);
+
+                        var clonedFile = 0;
+                        foreach (var file in Directory.EnumerateFiles(runtimeDir, "*", SearchOption.AllDirectories))
+                        {
+                            token.ThrowIfCancellationRequested();
+                            if (runnerCoreAssets.Any(x => file.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).EndsWith(x.Trim())))
+                            {
+                                Trace.Verbose($"{file} is part of the runner core, delete from cloned runtime directory.");
+                                IOUtil.DeleteFile(file);
+                            }
+                            else
+                            {
+                                clonedFile++;
+                            }
+                        }
+
+                        Trace.Info($"Successfully cloned dotnet runtime to {runtimeDir}. Total files: {clonedFile}");
+                        return true;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to clone dotnet runtime to {runtimeDir}");
+                Trace.Error(ex);
+            }
+            finally
+            {
+                stopWatch.Stop();
+                _updateTrace.Enqueue($"{nameof(CloneDotnetRuntime)}Time: {stopWatch.ElapsedMilliseconds}ms");
+            }
+
+            return false;
+        }
+
+        private Task<bool> CloneExternals(string externalsDir, CancellationToken token)
+        {
+            var stopWatch = Stopwatch.StartNew();
+            try
+            {
+                Trace.Info($"Cloning externals to {externalsDir}");
+                IOUtil.DeleteDirectory(externalsDir, CancellationToken.None);
+                Directory.CreateDirectory(externalsDir);
+                IOUtil.CopyDirectory(HostContext.GetDirectory(WellKnownDirectory.Externals), externalsDir, token);
+                Trace.Info($"Successfully cloned externals to {externalsDir}.");
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to clone externals to {externalsDir}");
+                Trace.Error(ex);
+            }
+            finally
+            {
+                stopWatch.Stop();
+                _updateTrace.Enqueue($"{nameof(CloneExternals)}Time: {stopWatch.ElapsedMilliseconds}ms");
+            }
+
+            return Task.FromResult(false);
+        }
+
+        private async Task<string> HashFiles(string fileFolder, CancellationToken token)
+        {
+            Trace.Info($"Calculating hash for {fileFolder}");
+
+            var stopWatch = Stopwatch.StartNew();
+            string binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
+            string node = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Externals), NodeUtil.GetInternalNodeVersion(), "bin", $"node{IOUtil.ExeExtension}");
+            string hashFilesScript = Path.Combine(binDir, "hashFiles");
+            var hashResult = string.Empty;
+
+            using (var processInvoker = HostContext.CreateService<IProcessInvoker>())
+            {
+                processInvoker.ErrorDataReceived += (_, data) =>
+                {
+                    if (!string.IsNullOrEmpty(data.Data) && data.Data.StartsWith("__OUTPUT__") && data.Data.EndsWith("__OUTPUT__"))
+                    {
+                        hashResult = data.Data.Substring(10, data.Data.Length - 20);
+                        Trace.Info($"Hash result: '{hashResult}'");
+                    }
+                    else
+                    {
+                        Trace.Info(data.Data);
+                    }
+                };
+
+                processInvoker.OutputDataReceived += (_, data) =>
+                {
+                    Trace.Verbose(data.Data);
+                };
+
+                var env = new Dictionary<string, string>
+                {
+                    ["patterns"] = "**"
+                };
+
+                int exitCode = await processInvoker.ExecuteAsync(workingDirectory: fileFolder,
+                                              fileName: node,
+                                              arguments: $"\"{hashFilesScript.Replace("\"", "\\\"")}\"",
+                                              environment: env,
+                                              requireExitCodeZero: false,
+                                              outputEncoding: null,
+                                              killProcessOnCancel: true,
+                                              cancellationToken: token);
+
+                if (exitCode != 0)
+                {
+                    Trace.Error($"hashFiles returns '{exitCode}' failed. Fail to hash files under directory '{fileFolder}'");
+                }
+
+                stopWatch.Stop();
+                _updateTrace.Enqueue($"{nameof(HashFiles)}{Path.GetFileName(fileFolder)}Time: {stopWatch.ElapsedMilliseconds}ms");
+                return hashResult;
+            }
+        }
     }
 }

src/Runner.Listener/SelfUpdaterV2.cs

@@ -149,6 +149,7 @@ namespace GitHub.Runner.Listener
 
             string archiveFile = null;
 
+            // Only try trimmed package if sever sends them and we have calculated hash value of the current runtime/externals.
             _updateTrace.Enqueue($"DownloadUrl: {packageDownloadUrl}");
 
             try

src/Runner.PluginHost/Runner.PluginHost.csproj

@@ -1,12 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <RuntimeIdentifiers>win-x64;win-x86;linux-x64;linux-arm64;linux-arm;osx-x64;osx-arm64;win-arm64</RuntimeIdentifiers>
-    <SelfContained>true</SelfContained>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
-    <NoWarn>NU1701;NU1603;SYSLIB0050;SYSLIB0051</NoWarn>
+    <NoWarn>NU1701;NU1603</NoWarn>
     <Version>$(Version)</Version>
     <PredefinedCulturesOnly>false</PredefinedCulturesOnly>
     <PublishReadyToRunComposite>true</PublishReadyToRunComposite>

src/Runner.Plugins/Runner.Plugins.csproj

@@ -1,12 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Library</OutputType>
     <RuntimeIdentifiers>win-x64;win-x86;linux-x64;linux-arm64;linux-arm;osx-x64;osx-arm64;win-arm64</RuntimeIdentifiers>
-    <SelfContained>true</SelfContained>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
-    <NoWarn>NU1701;NU1603;SYSLIB0050;SYSLIB0051</NoWarn>
+    <NoWarn>NU1701;NU1603</NoWarn>
     <Version>$(Version)</Version>
   </PropertyGroup>
 

src/Runner.Sdk/Runner.Sdk.csproj

@@ -1,12 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Library</OutputType>
     <RuntimeIdentifiers>win-x64;win-x86;linux-x64;linux-arm64;linux-arm;osx-x64;osx-arm64;win-arm64</RuntimeIdentifiers>
-    <SelfContained>true</SelfContained>
     <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
-    <NoWarn>NU1701;NU1603;SYSLIB0050;SYSLIB0051</NoWarn>
+    <NoWarn>NU1701;NU1603</NoWarn>
     <Version>$(Version)</Version>
   </PropertyGroup>
 
@@ -15,9 +14,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="8.0.0" />
-    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
-    <PackageReference Include="System.Threading.Channels" Version="8.0.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.4.0" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="4.4.0" />
+    <PackageReference Include="System.Threading.Channels" Version="4.4.0" />
   </ItemGroup>
 
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

src/Runner.Sdk/Util/IOUtil.cs

@@ -459,34 +459,6 @@ namespace GitHub.Runner.Sdk
             File.WriteAllText(path, null);
         }
 
-        /// <summary>
-        /// Replaces invalid file name characters with '_'
-        /// </summary>
-        public static string ReplaceInvalidFileNameChars(string fileName)
-        {
-            var result = new StringBuilder();
-            var invalidChars = Path.GetInvalidFileNameChars();
-
-            var current = 0; // Current index
-            while (current < fileName?.Length)
-            {
-                var next = fileName.IndexOfAny(invalidChars, current);
-                if (next >= 0)
-                {
-                    result.Append(fileName.Substring(current, next - current));
-                    result.Append('_');
-                    current = next + 1;
-                }
-                else
-                {
-                    result.Append(fileName.Substring(current));
-                    break;
-                }
-            }
-
-            return result.ToString();
-        }
-
         /// <summary>
         /// Recursively enumerates a directory without following directory reparse points.
         /// </summary>

src/Runner.Sdk/Util/UrlUtil.cs

@@ -60,15 +60,5 @@ namespace GitHub.Runner.Sdk
             }
             return string.Empty;
         }
-
-        public static string GetVssRequestId(HttpResponseHeaders headers)
-        {
-            if (headers != null &&
-                headers.TryGetValues("x-vss-e2eid", out var headerValues))
-            {
-                return headerValues.FirstOrDefault();
-            }
-            return string.Empty;
-        }
     }
 }