Release 2.301.1 runner with reverting #2333 (#2384)

* Revert "split by regex (#2333)"

This reverts commit 72830cfc12.

* Release 2.301.1 runner.

.devcontainer/devcontainer.json

@@ -0,0 +1,27 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+{
+	"name": "Actions Runner Devcontainer",
+	"image": "mcr.microsoft.com/devcontainers/base:focal",
+	"features": {
+		"ghcr.io/devcontainers/features/docker-in-docker:1": {},
+		"ghcr.io/devcontainers/features/dotnet": {
+			"version": "6.0.300"
+		},
+		"ghcr.io/devcontainers/features/node:1": {
+			"version": "16"
+		}
+	},
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-azuretools.vscode-docker",
+				"ms-dotnettools.csharp",
+				"eamodio.gitlens"
+			]
+		}
+	},
+	// dotnet restore to install dependencies so OmniSharp works out of the box
+	// src/Test restores all other projects it references, src/Runner.PluginHost is not one of them
+	"postCreateCommand": "dotnet restore src/Test && dotnet restore src/Runner.PluginHost",
+	"remoteUser": "vscode"
+}

.editorconfig

@@ -1,6 +1,7 @@
 # https://editorconfig.org/
 
 [*]
+charset = utf-8 # Set default charset to utf-8
 insert_final_newline = true # ensure all files end with a single newline
 trim_trailing_whitespace = true # attempt to remove trailing whitespace on save
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: 🛑 Request a feature in the runner application
+    url: https://github.com/orgs/community/discussions/categories/actions-and-packages
+    about: If you have feature requests for GitHub Actions, please use the Actions and Packages section on the Github Product Feedback page.
   - name: ✅ Support for GitHub Actions
     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.

.github/ISSUE_TEMPLATE/enhancement_request.md

@@ -1,32 +0,0 @@
----
-name: 🛑 Request a feature in the runner application 
-about: If you have feature requests for GitHub Actions, please use the "feedback and suggestions for GitHub Actions" link below.
-title: ''
-labels: enhancement
-assignees: ''
-
----
-
-<!--
-👋 You're opening a request for an enhancement in the GitHub Actions **runner application**.
-
-🛑 Please stop if you're not certain that the feature you want is in the runner application - if you have a suggestion for improving GitHub Actions, please see the [GitHub Actions Feedback](https://github.com/github/feedback/discussions/categories/actions-and-packages-feedback) discussion forum which is actively monitored.  Using the forum ensures that we route your problem to the correct team.  😃
-
-Some additional useful links:
-* If you have found a security issue [please submit it here](https://hackerone.com/github)
-* If you have questions or issues with the service, writing workflows or actions, then please [visit the GitHub Community Forum's Actions Board](https://github.community/t5/GitHub-Actions/bd-p/actions)
-* If you are having an issue or have a question about GitHub Actions then please [contact customer support](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-github-actions#contacting-support)
-
-If you have a feature request that is relevant to this repository, the runner, then please include the information below:
--->
-
-**Describe the enhancement**
-A clear and concise description of what the features or enhancement you need.
-
-**Code Snippet**
-If applicable, add a code snippet.
-
-**Additional information**
-Add any other context about the feature here.
-
-NOTE: if the feature request has been agreed upon then the assignee will create an ADR.   See docs/adrs/README.md

.github/workflows/lint.yml

@@ -0,0 +1,25 @@
+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 }}
+          DISABLE_ERRORS: true
+          EDITORCONFIG_FILE_NAME: .editorconfig
+          LINTER_RULES_PATH: /src/
+          VALIDATE_ALL_CODEBASE: false
+          VALIDATE_CSHARP: true

.github/workflows/publish-image.yml

@@ -0,0 +1,65 @@
+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
+          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

@@ -247,28 +247,28 @@ jobs:
           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)
           releaseNote = releaseNote.replace(/<WIN_X64_SHA>/g, '${{needs.build.outputs.win-x64-sha}}')
-          releaseNote = releaseNote.replace(/<WIN_X64_SHA>/g, '${{needs.build.outputs.win-arm64-sha}}')
+          releaseNote = releaseNote.replace(/<WIN_ARM64_SHA>/g, '${{needs.build.outputs.win-arm64-sha}}')
           releaseNote = releaseNote.replace(/<OSX_X64_SHA>/g, '${{needs.build.outputs.osx-x64-sha}}')
           releaseNote = releaseNote.replace(/<OSX_ARM64_SHA>/g, '${{needs.build.outputs.osx-arm64-sha}}')
           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_X64_SHA_NOEXTERNALS>/g, '${{needs.build.outputs.win-arm64-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_X64_SHA_NORUNTIME>/g, '${{needs.build.outputs.win-arm64-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_X64_SHA_NORUNTIME_NOEXTERNALS>/g, '${{needs.build.outputs.win-arm64-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}}')
@@ -660,3 +660,52 @@ jobs:
         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
+    env:
+      REGISTRY: ghcr.io
+      IMAGE_NAME: ${{ github.repository_owner }}/actions-runner
+    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 runnerVersion = fs.readFileSync('${{ github.workspace }}/releaseVersion', '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
+          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

README.md

@@ -22,4 +22,4 @@ Runner releases:
 
 ## Contribute
 
-We accept contributions in the form of issues and pull requests.  [Read more here](docs/contribute.md) before contributing.
+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/checks/actions.md

@@ -64,4 +64,4 @@ Make sure the runner has access to actions service for GitHub.com or GitHub Ente
   
 ## Still not working?
 
-Contact [GitHub Support](https://support.github.com] if you have further questuons, or log an issue at https://github.com/actions/runner if you think it's a runner issue.
+Contact [GitHub Support](https://support.github.com) if you have further questuons, or log an issue at https://github.com/actions/runner if you think it's a runner issue.

docs/contribute.md

@@ -1,6 +1,6 @@
 # Contributions
 
-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.
+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.
 

docs/contribute/vscode.md

@@ -35,7 +35,7 @@ All the configs below can be found in `.vscode/launch.json`.
 If you launch `Run` or `Run [build]`, it starts a process called `Runner.Listener`.
 This process will receive any job queued on this repository if the job runs on matching labels (e.g `runs-on: self-hosted`).
 Once a job is received, a `Runner.Listener` starts a new process of `Runner.Worker`.
-Since this is a diferent process, you can't use the same debugger session debug it.
+Since this is a different process, you can't use the same debugger session debug it.
 Instead, a parallel debugging session has to be started, using a different launch config.
 Luckily, VS Code supports multiple parallel debugging sessions.
 

images/Dockerfile

@@ -0,0 +1,25 @@
+FROM mcr.microsoft.com/dotnet/runtime-deps:6.0 as build
+
+ARG RUNNER_VERSION
+ARG RUNNER_ARCH="x64"
+ARG RUNNER_CONTAINER_HOOKS_VERSION=0.2.0
+
+RUN apt update -y && apt install curl unzip -y
+
+WORKDIR /actions-runner
+RUN curl -f -L -o runner.tar.gz https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-${RUNNER_ARCH}-${RUNNER_VERSION}.tar.gz \
+    && tar xzf ./runner.tar.gz \
+    && rm runner.tar.gz
+
+RUN curl -f -L -o runner-container-hooks.zip https://github.com/actions/runner-container-hooks/releases/download/v${RUNNER_CONTAINER_HOOKS_VERSION}/actions-runner-hooks-k8s-${RUNNER_CONTAINER_HOOKS_VERSION}.zip \
+    && unzip ./runner-container-hooks.zip -d ./k8s \
+    && rm runner-container-hooks.zip
+
+FROM mcr.microsoft.com/dotnet/runtime-deps:6.0
+
+ENV RUNNER_ALLOW_RUNASROOT=1
+ENV RUNNER_MANUALLY_TRAP_SIG=1
+ENV ACTIONS_RUNNER_PRINT_LOG_TO_STDOUT=1
+
+WORKDIR /actions-runner
+COPY --from=build /actions-runner .

releaseNote.md

@@ -1,11 +1,23 @@
 ## Features
-- Service containers startup error logs are now included in workflow's logs (#2110)
+- Log GitHub RequestId for better traceability (#2332)
+- Dual upload summary to Actions and Result service (#2334)
+- Allow providing extra User-Agent for better correlation (#2370)
+- Show more information in the runner log (#2377)
+- New option to remove local config files (#2367)
 
-<!-- ## Bugs -->
+## Bugs
+- Treat jitconfig as secret (#2335)
+- Add Header/Footer to multi-line message in StdoutTraceListener (#2336)
+- Update Node dependencies (#2381)
 
 ## Misc
-- Added a feature flag to start warning on `save-state` and `set-output` deprecation (#2164)
-- Prepare supporting `vars` in workflow templates (#2096)
+- Make runner image print diag log to STDOUT (#2331)
+- Update Node.js to 16.16.0 (#2371)
+- Add a disclaimer for which runner version is available to a given tenant (#2362)
+
+_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.

releaseVersion

@@ -1 +1 @@
-<Update to ./src/runnerversion when creating release>
+2.301.1

scripts/create-latest-svc.sh

@@ -13,7 +13,7 @@ set -e
 
 flags_found=false
 
-while getopts 's:g:n:r:u:l:' opt; do
+while getopts 's:g:n:r:u:l:df' opt; do
     flags_found=true
 
     case $opt in
@@ -35,6 +35,12 @@ while getopts 's:g:n:r:u:l:' opt; do
     l)
         labels=$OPTARG
         ;;
+    f)
+        replace='true'
+        ;;
+    d)
+        disableupdate='true'
+        ;;
     *)
         echo "
 Runner Service Installer
@@ -49,7 +55,9 @@ Usage:
     -n          optional  name of the runner, defaults to hostname
     -r          optional  name of the runner group to add the runner to, defaults to the Default group
     -u          optional  user svc will run as, defaults to current
-    -l          optional  list of labels (split by comma) applied on the runner"
+    -l          optional  list of labels (split by comma) applied on the runner
+    -d          optional  allow runner to remain on the current version for one month after the release of a newer version
+    -f          optional  replace any existing runner with the same name"
         exit 0
         ;;
     esac
@@ -169,8 +177,8 @@ fi
 
 echo
 echo "Configuring ${runner_name} @ $runner_url"
-echo "./config.sh --unattended --url $runner_url --token *** --name $runner_name ${labels:+--labels $labels} ${runner_group:+--runnergroup \"$runner_group\"}"
-sudo -E -u ${svc_user} ./config.sh --unattended --url $runner_url --token $RUNNER_TOKEN --name $runner_name ${labels:+--labels $labels} ${runner_group:+--runnergroup "$runner_group"}
+echo "./config.sh --unattended --url $runner_url --token *** --name $runner_name ${labels:+--labels $labels} ${runner_group:+--runnergroup \"$runner_group\"} ${disableupdate:+--disableupdate}"
+sudo -E -u ${svc_user} ./config.sh --unattended --url $runner_url --token $RUNNER_TOKEN ${replace:+--replace} --name $runner_name ${labels:+--labels $labels} ${runner_group:+--runnergroup "$runner_group"} ${disableupdate:+--disableupdate}
 
 #---------------------------------------
 # Configuring as a service

scripts/delete.sh

@@ -1,4 +1,4 @@
-#/bin/bash
+#!/bin/bash
 
 set -e
 
@@ -12,7 +12,7 @@ set -e
 #
 # Usage:
 #     export RUNNER_CFG_PAT=<yourPAT>
-#     ./delete.sh scope name
+#     ./delete.sh <scope> [<name>]
 #
 #      scope required  repo (:owner/:repo) or org (:organization)
 #      name  optional  defaults to hostname.  name to delete
@@ -26,8 +26,6 @@ set -e
 runner_scope=${1}
 runner_name=${2}
 
-echo "Deleting runner ${runner_name} @ ${runner_scope}"
-
 function fatal() 
 {
    echo "error: $1" >&2
@@ -35,8 +33,10 @@ function fatal()
 }
 
 if [ -z "${runner_scope}" ]; then fatal "supply scope as argument 1"; fi
-if [ -z "${runner_name}" ]; then fatal "supply name as argument 2"; fi
 if [ -z "${RUNNER_CFG_PAT}" ]; then fatal "RUNNER_CFG_PAT must be set before calling"; fi
+if [ -z "${runner_name}" ]; then runner_name=`hostname`; fi
+
+echo "Deleting runner ${runner_name} @ ${runner_scope}"
 
 which curl || fatal "curl required.  Please install in PATH with apt-get, brew, etc"
 which jq || fatal "jq required.  Please install in PATH with apt-get, brew, etc"

src/Misc/contentHash/externals/linux-arm

@@ -1 +1 @@
-6ed30a2c1ee403a610d63e82bb230b9ba846a9c25cec9e4ea8672fb6ed4e1a51
+3807dcbf947e840c33535fb466b096d76bf09e5c0254af8fc8cbbb24c6388222

src/Misc/contentHash/externals/linux-arm64

@@ -1 +1 @@
-711c30c51ec52c9b7a9a2eb399d6ab2ab5ee1dc72de11879f2f36f919f163d78
+ee01eee80cd8a460a4b9780ee13fdd20f25c59e754b4ccd99df55fbba2a85634

src/Misc/contentHash/externals/linux-x64

@@ -1 +1 @@
-a49479ca4b4988a06c097e8d22c51fd08a11c13f40807366236213d0e008cf6a
+a9fb9c14e24e79aec97d4da197dd7bfc6364297d6fce573afb2df48cc9a931f8

src/Misc/contentHash/externals/osx-arm64

@@ -1 +1 @@
-cc4708962a80325de0baa5ae8484e0cb9ae976ac6a4178c1c0d448b8c52bd7f7
+a4e0e8fc62eba0967a39c7d693dcd0aeb8b2bed0765f9c38df80d42884f65341

src/Misc/contentHash/externals/osx-x64

@@ -1 +1 @@
-8e97df75230b843462a9b4c578ccec604ee4b4a1066120c85b04374317fa372b
+17ac17fbe785b3d6fa2868d8d17185ebfe0c90b4b0ddf6b67eac70e42bcd989b

src/Misc/contentHash/externals/win-arm64

@@ -1 +1 @@
-e5dace2d41cc0682d096dcce4970079ad48ec7107e46195970eecfdb3df2acef
+89f24657a550f1e818b0e9975e5b80edcf4dd22b7d4bccbb9e48e37f45d30fb1

src/Misc/contentHash/externals/win-x64

@@ -1 +1 @@
-f75a671e5a188c76680739689aa75331a2c09d483dce9c80023518c48fd67a18
+24fd131b5dce33ef16038b771407bc0507da8682a72fb3b7780607235f76db0b

src/Misc/expressionFunc/hashFiles/package-lock.json

@@ -14,7 +14,7 @@
       "devDependencies": {
         "@types/node": "^12.7.12",
         "@typescript-eslint/parser": "^5.15.0",
-        "@zeit/ncc": "^0.20.5",
+        "@vercel/ncc": "^0.36.0",
         "eslint": "^8.11.0",
         "eslint-plugin-github": "^4.3.5",
         "prettier": "^1.19.1",
@@ -346,11 +346,10 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
-    "node_modules/@zeit/ncc": {
-      "version": "0.20.5",
-      "resolved": "https://registry.npmjs.org/@zeit/ncc/-/ncc-0.20.5.tgz",
-      "integrity": "sha512-XU6uzwvv95DqxciQx+aOLhbyBx/13ky+RK1y88Age9Du3BlA4mMPCy13BGjayOrrumOzlq1XV3SD/BWiZENXlw==",
-      "deprecated": "@zeit/ncc is no longer maintained. Please use @vercel/ncc instead.",
+    "node_modules/@vercel/ncc": {
+      "version": "0.36.0",
+      "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.36.0.tgz",
+      "integrity": "sha512-/ZTUJ/ZkRt694k7KJNimgmHjtQcRuVwsST2Z6XfYveQIuBbHR+EqkTc1jfgPkQmMyk/vtpxo3nVxe8CNuau86A==",
       "dev": true,
       "bin": {
         "ncc": "dist/ncc/cli.js"
@@ -1722,9 +1721,9 @@
       "dev": true
     },
     "node_modules/json5": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
-      "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
+      "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
       "dev": true,
       "dependencies": {
         "minimist": "^1.2.0"
@@ -1824,9 +1823,9 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "dependencies": {
         "brace-expansion": "^1.1.7"
       },
@@ -2747,10 +2746,10 @@
         "eslint-visitor-keys": "^3.0.0"
       }
     },
-    "@zeit/ncc": {
-      "version": "0.20.5",
-      "resolved": "https://registry.npmjs.org/@zeit/ncc/-/ncc-0.20.5.tgz",
-      "integrity": "sha512-XU6uzwvv95DqxciQx+aOLhbyBx/13ky+RK1y88Age9Du3BlA4mMPCy13BGjayOrrumOzlq1XV3SD/BWiZENXlw==",
+    "@vercel/ncc": {
+      "version": "0.36.0",
+      "resolved": "https://registry.npmjs.org/@vercel/ncc/-/ncc-0.36.0.tgz",
+      "integrity": "sha512-/ZTUJ/ZkRt694k7KJNimgmHjtQcRuVwsST2Z6XfYveQIuBbHR+EqkTc1jfgPkQmMyk/vtpxo3nVxe8CNuau86A==",
       "dev": true
     },
     "acorn": {
@@ -3756,9 +3755,9 @@
       "dev": true
     },
     "json5": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
-      "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
+      "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
       "dev": true,
       "requires": {
         "minimist": "^1.2.0"
@@ -3840,9 +3839,9 @@
       }
     },
     "minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "requires": {
         "brace-expansion": "^1.1.7"
       }

src/Misc/expressionFunc/hashFiles/package.json

@@ -26,7 +26,7 @@
   "devDependencies": {
     "@types/node": "^12.7.12",
     "@typescript-eslint/parser": "^5.15.0",
-    "@zeit/ncc": "^0.20.5",
+    "@vercel/ncc": "^0.36.0",
     "eslint": "^8.11.0",
     "eslint-plugin-github": "^4.3.5",
     "prettier": "^1.19.1",

src/Misc/externals.sh

@@ -5,7 +5,7 @@ PRECACHE=$2
 NODE_URL=https://nodejs.org/dist
 UNOFFICIAL_NODE_URL=https://unofficial-builds.nodejs.org/download/release
 NODE12_VERSION="12.22.7"
-NODE16_VERSION="16.13.0"
+NODE16_VERSION="16.16.0"
 
 get_abs_path() {
   # exploits the fact that pwd will print abs path when no args

src/Misc/layoutroot/run.sh

@@ -9,9 +9,11 @@ while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symli
     [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
 done
 DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-# run the helper process which keep the listener alive
-while :;
-do
+
+run() {
+    # run the helper process which keep the listener alive
+    while :;
+    do
         cp -f "$DIR"/run-helper.sh.template "$DIR"/run-helper.sh
         "$DIR"/run-helper.sh $*
         returnCode=$?
@@ -21,4 +23,38 @@ do
             echo "Exiting runner..."
             exit 0
         fi
-done
+    done
+}
+
+runWithManualTrap() {
+    # Set job control
+    set -m
+
+    trap 'kill -INT -$PID' INT TERM
+
+    # run the helper process which keep the listener alive
+    while :;
+    do
+        cp -f "$DIR"/run-helper.sh.template "$DIR"/run-helper.sh
+        "$DIR"/run-helper.sh $* &
+        PID=$!
+        wait -f $PID
+        returnCode=$?
+        if [[ $returnCode -eq 2 ]]; then
+            echo "Restarting runner..."
+        else
+            echo "Exiting runner..."
+            # Unregister signal handling before exit
+            trap - INT TERM
+            # wait for last parts to be logged
+            wait $PID
+            exit $returnCode
+        fi
+    done
+}
+
+if [[ -z "$RUNNER_MANUALLY_TRAP_SIG" ]]; then
+    run $*
+else
+    runWithManualTrap $*
+fi

src/Runner.Common/ActionCommand.cs

@@ -31,7 +31,7 @@ namespace GitHub.Runner.Common
             new EscapeMapping(token: "%", replacement: "%25"),
         };
 
-        private readonly Dictionary<string, string> _properties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, string> _properties = new(StringComparer.OrdinalIgnoreCase);
         public const string Prefix = "##[";
         public const string _commandKey = "::";
 

src/Runner.Common/ActionsRunServer.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.DistributedTask.Pipelines;
+using GitHub.DistributedTask.WebApi;
+using GitHub.Services.Common;
+using GitHub.Services.WebApi;
+
+namespace GitHub.Runner.Common
+{
+    [ServiceLocator(Default = typeof(ActionsRunServer))]
+    public interface IActionsRunServer : IRunnerService
+    {
+        Task ConnectAsync(Uri serverUrl, VssCredentials credentials);
+
+        Task<AgentJobRequestMessage> GetJobMessageAsync(string id, CancellationToken token);
+    }
+
+    public sealed class ActionsRunServer : RunnerService, IActionsRunServer
+    {
+        private bool _hasConnection;
+        private VssConnection _connection;
+        private TaskAgentHttpClient _taskAgentClient;
+
+        public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
+        {
+            _connection = await EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
+            _taskAgentClient = _connection.GetClient<TaskAgentHttpClient>();
+            _hasConnection = true;
+        }
+
+        private void CheckConnection()
+        {
+            if (!_hasConnection)
+            {
+                throw new InvalidOperationException($"SetConnection");
+            }
+        }
+
+        public Task<AgentJobRequestMessage> GetJobMessageAsync(string id, CancellationToken cancellationToken)
+        {
+            CheckConnection();
+            var jobMessage = RetryRequest<AgentJobRequestMessage>(async () =>
+                                                    {
+                                                        return await _taskAgentClient.GetJobMessageAsync(id, cancellationToken);
+                                                    }, cancellationToken);
+
+            return jobMessage;
+        }
+    }
+}

src/Runner.Common/ConfigurationStore.cs

@@ -74,17 +74,18 @@ namespace GitHub.Runner.Common
         {
             get
             {
-                Uri accountUri = new Uri(this.ServerUrl);
+                Uri accountUri = new(this.ServerUrl);
                 string repoOrOrgName = string.Empty;
 
-                if (accountUri.Host.EndsWith(".githubusercontent.com", StringComparison.OrdinalIgnoreCase))
+                if (accountUri.Host.EndsWith(".githubusercontent.com", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(this.GitHubUrl))
                 {
-                    Uri gitHubUrl = new Uri(this.GitHubUrl);
+                    Uri gitHubUrl = new(this.GitHubUrl);
 
                     // Use the "NWO part" from the GitHub URL path
                     repoOrOrgName = gitHubUrl.AbsolutePath.Trim('/');
                 }
-                else
+
+                if (string.IsNullOrEmpty(repoOrOrgName))
                 {
                     repoOrOrgName = accountUri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
                 }

src/Runner.Common/Constants.cs

@@ -90,7 +90,6 @@ namespace GitHub.Runner.Common
                 public static class Args
                 {
                     public static readonly string Auth = "auth";
-                    public static readonly string JitConfig = "jitconfig";
                     public static readonly string Labels = "labels";
                     public static readonly string MonitorSocketAddress = "monitorsocketaddress";
                     public static readonly string Name = "name";
@@ -105,11 +104,13 @@ namespace GitHub.Runner.Common
                     public static readonly string Token = "token";
                     public static readonly string PAT = "pat";
                     public static readonly string WindowsLogonPassword = "windowslogonpassword";
+                    public static readonly string JitConfig = "jitconfig";
                     public static string[] Secrets => new[]
                     {
                         PAT,
                         Token,
                         WindowsLogonPassword,
+                        JitConfig,
                     };
                 }
 
@@ -128,7 +129,9 @@ namespace GitHub.Runner.Common
                     public static readonly string Check = "check";
                     public static readonly string Commit = "commit";
                     public static readonly string Ephemeral = "ephemeral";
+                    public static readonly string GenerateServiceConfig = "generateServiceConfig";
                     public static readonly string Help = "help";
+                    public static readonly string Local = "local";
                     public static readonly string Replace = "replace";
                     public static readonly string DisableUpdate = "disableupdate";
                     public static readonly string Once = "once"; // Keep this around since customers still relies on it
@@ -156,14 +159,17 @@ namespace GitHub.Runner.Common
             }
 
             public static readonly string InternalTelemetryIssueDataKey = "_internal_telemetry";
+            public static readonly Guid TelemetryRecordId = new Guid("11111111-1111-1111-1111-111111111111");
             public static readonly string WorkerCrash = "WORKER_CRASH";
             public static readonly string LowDiskSpace = "LOW_DISK_SPACE";
             public static readonly string UnsupportedCommand = "UNSUPPORTED_COMMAND";
+            public static readonly string ResultsUploadFailure = "RESULTS_UPLOAD_FAILURE";
             public static readonly string UnsupportedCommandMessage = "The `{0}` command is deprecated and will be disabled soon. Please upgrade to using Environment Files. For more information see: https://github.blog/changelog/2022-10-11-github-actions-deprecating-save-state-and-set-output-commands/";
             public static readonly string UnsupportedCommandMessageDisabled = "The `{0}` command is disabled. Please upgrade to using Environment Files or opt into unsecure command execution by setting the `ACTIONS_ALLOW_UNSECURE_COMMANDS` environment variable to `true`. For more information see: https://github.blog/changelog/2020-10-01-github-actions-deprecating-set-env-and-add-path-commands/";
             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 Node12DetectedAfterEndOfLife = "Node.js 12 actions are deprecated. For more information see: https://github.blog/changelog/2022-09-22-github-actions-all-actions-will-begin-running-on-node16-instead-of-node12/. Please update the following actions to use Node.js 16: {0}";
+            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 Node12DetectedAfterEndOfLife = "Node.js 12 actions are deprecated. Please update the following actions to use Node.js 16: {0}. For more information see: https://github.blog/changelog/2022-09-22-github-actions-all-actions-will-begin-running-on-node16-instead-of-node12/.";
         }
 
         public static class RunnerEvent
@@ -244,6 +250,7 @@ namespace GitHub.Runner.Common
                 // 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";
             }
 
             public static class System

src/Runner.Common/ExtensionManager.cs

@@ -14,7 +14,7 @@ namespace GitHub.Runner.Common
 
     public sealed class ExtensionManager : RunnerService, IExtensionManager
     {
-        private readonly ConcurrentDictionary<Type, List<IExtension>> _cache = new ConcurrentDictionary<Type, List<IExtension>>();
+        private readonly ConcurrentDictionary<Type, List<IExtension>> _cache = new();
 
         public List<T> GetExtensions<T>() where T : class, IExtension
         {

src/Runner.Common/HostContext.cs

@@ -51,12 +51,12 @@ namespace GitHub.Runner.Common
         private static int _defaultLogRetentionDays = 30;
         private static int[] _vssHttpMethodEventIds = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 24 };
         private static int[] _vssHttpCredentialEventIds = new int[] { 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 27, 29 };
-        private readonly ConcurrentDictionary<Type, object> _serviceInstances = new ConcurrentDictionary<Type, object>();
-        private readonly ConcurrentDictionary<Type, Type> _serviceTypes = new ConcurrentDictionary<Type, Type>();
+        private readonly ConcurrentDictionary<Type, object> _serviceInstances = new();
+        private readonly ConcurrentDictionary<Type, Type> _serviceTypes = new();
         private readonly ISecretMasker _secretMasker = new SecretMasker();
-        private readonly List<ProductInfoHeaderValue> _userAgents = new List<ProductInfoHeaderValue>() { new ProductInfoHeaderValue($"GitHubActionsRunner-{BuildConstants.RunnerPackage.PackageName}", BuildConstants.RunnerPackage.Version) };
-        private CancellationTokenSource _runnerShutdownTokenSource = new CancellationTokenSource();
-        private object _perfLock = new object();
+        private readonly List<ProductInfoHeaderValue> _userAgents = new() { new ProductInfoHeaderValue($"GitHubActionsRunner-{BuildConstants.RunnerPackage.PackageName}", BuildConstants.RunnerPackage.Version) };
+        private CancellationTokenSource _runnerShutdownTokenSource = new();
+        private object _perfLock = new();
         private Tracing _trace;
         private Tracing _actionsHttpTrace;
         private Tracing _netcoreHttpTrace;
@@ -66,7 +66,7 @@ namespace GitHub.Runner.Common
         private IDisposable _diagListenerSubscription;
         private StartupType _startupType;
         private string _perfFile;
-        private RunnerWebProxy _webProxy = new RunnerWebProxy();
+        private RunnerWebProxy _webProxy = new();
 
         public event EventHandler Unloading;
         public CancellationToken RunnerShutdownToken => _runnerShutdownTokenSource.Token;
@@ -94,6 +94,13 @@ namespace GitHub.Runner.Common
             this.SecretMasker.AddValueEncoder(ValueEncoders.PowerShellPreAmpersandEscape);
             this.SecretMasker.AddValueEncoder(ValueEncoders.PowerShellPostAmpersandEscape);
 
+            // Create StdoutTraceListener if ENV is set
+            StdoutTraceListener stdoutTraceListener = null;
+            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable(Constants.Variables.Agent.PrintLogToStdout)))
+            {
+                stdoutTraceListener = new StdoutTraceListener(hostType);
+            }
+
             // Create the trace manager.
             if (string.IsNullOrEmpty(logFile))
             {
@@ -113,11 +120,11 @@ namespace GitHub.Runner.Common
 
                 // this should give us _diag folder under runner root directory
                 string diagLogDirectory = Path.Combine(new DirectoryInfo(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location)).Parent.FullName, Constants.Path.DiagDirectory);
-                _traceManager = new TraceManager(new HostTraceListener(diagLogDirectory, hostType, logPageSize, logRetentionDays), this.SecretMasker);
+                _traceManager = new TraceManager(new HostTraceListener(diagLogDirectory, hostType, logPageSize, logRetentionDays), stdoutTraceListener, this.SecretMasker);
             }
             else
             {
-                _traceManager = new TraceManager(new HostTraceListener(logFile), this.SecretMasker);
+                _traceManager = new TraceManager(new HostTraceListener(logFile), stdoutTraceListener, this.SecretMasker);
             }
 
             _trace = GetTrace(nameof(HostContext));
@@ -219,6 +226,20 @@ namespace GitHub.Runner.Common
             }
 
             _userAgents.Add(new ProductInfoHeaderValue("CommitSHA", BuildConstants.Source.CommitHash));
+
+            var extraUserAgent = Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_EXTRA_USER_AGENT");
+            if (!string.IsNullOrEmpty(extraUserAgent))
+            {
+                var extraUserAgentSplit = extraUserAgent.Split('/', StringSplitOptions.RemoveEmptyEntries);
+                if (extraUserAgentSplit.Length != 2)
+                {
+                    _trace.Error($"GITHUB_ACTIONS_RUNNER_EXTRA_USER_AGENT is not in the format of 'name/version'.");
+                }
+
+                var extraUserAgentHeader = new ProductInfoHeaderValue(extraUserAgentSplit[0], extraUserAgentSplit[1]);
+                _trace.Info($"Adding extra user agent '{extraUserAgentHeader}' to all HTTP requests.");
+                _userAgents.Add(extraUserAgentHeader);
+            }
         }
 
         public string GetDirectory(WellKnownDirectory directory)

src/Runner.Common/HostTraceListener.cs

@@ -164,7 +164,7 @@ namespace GitHub.Runner.Common
         {
             if (_enableLogRetention)
             {
-                DirectoryInfo diags = new DirectoryInfo(_logFileDirectory);
+                DirectoryInfo diags = new(_logFileDirectory);
                 var logs = diags.GetFiles($"{_logFilePrefix}*.log");
                 foreach (var log in logs)
                 {

src/Runner.Common/JobServer.cs

@@ -13,6 +13,8 @@ using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using GitHub.Services.WebApi;
 using GitHub.Services.WebApi.Utilities.Internal;
+using GitHub.Services.Results.Client;
+using GitHub.Services.OAuth;
 
 namespace GitHub.Runner.Common
 {
@@ -22,11 +24,13 @@ namespace GitHub.Runner.Common
         Task ConnectAsync(VssConnection jobConnection);
 
         void InitializeWebsocketClient(ServiceEndpoint serviceEndpoint);
+        void InitializeResultsClient(Uri uri, string token);
 
         // logging and console
         Task<TaskLog> AppendLogContentAsync(Guid scopeIdentifier, string hubName, Guid planId, int logId, Stream uploadStream, CancellationToken cancellationToken);
         Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long? startLine, CancellationToken cancellationToken);
         Task<TaskAttachment> CreateAttachmentAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, String type, String name, Stream uploadStream, CancellationToken cancellationToken);
+        Task CreateStepSymmaryAsync(string planId, string jobId, string stepId, string file, CancellationToken cancellationToken);
         Task<TaskLog> CreateLogAsync(Guid scopeIdentifier, string hubName, Guid planId, TaskLog log, CancellationToken cancellationToken);
         Task<Timeline> CreateTimelineAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, CancellationToken cancellationToken);
         Task<List<TimelineRecord>> UpdateTimelineRecordsAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, IEnumerable<TimelineRecord> records, CancellationToken cancellationToken);
@@ -40,6 +44,7 @@ namespace GitHub.Runner.Common
         private bool _hasConnection;
         private VssConnection _connection;
         private TaskHttpClient _taskClient;
+        private ResultsHttpClient _resultsClient;
         private ClientWebSocket _websocketClient;
 
         private ServiceEndpoint _serviceEndpoint;
@@ -143,6 +148,12 @@ namespace GitHub.Runner.Common
             InitializeWebsocketClient(TimeSpan.Zero);
         }
 
+        public void InitializeResultsClient(Uri uri, string token)
+        {
+            var httpMessageHandler = HostContext.CreateHttpClientHandler();
+            this._resultsClient = new ResultsHttpClient(uri, httpMessageHandler, token, disposeHandler: true);
+        }
+
         public ValueTask DisposeAsync()
         {
             CloseWebSocket(WebSocketCloseStatus.NormalClosure, CancellationToken.None);
@@ -305,6 +316,16 @@ namespace GitHub.Runner.Common
             return _taskClient.CreateAttachmentAsync(scopeIdentifier, hubName, planId, timelineId, timelineRecordId, type, name, uploadStream, cancellationToken: cancellationToken);
         }
 
+        public Task CreateStepSymmaryAsync(string planId, string jobId, string stepId, string file, CancellationToken cancellationToken)
+        {
+            if (_resultsClient != null)
+            {
+                return _resultsClient.UploadStepSummaryAsync(planId, jobId, stepId, file, cancellationToken: cancellationToken);
+            }
+            throw new InvalidOperationException("Results client is not initialized.");
+        }
+
+
         public Task<TaskLog> CreateLogAsync(Guid scopeIdentifier, string hubName, Guid planId, TaskLog log, CancellationToken cancellationToken)
         {
             CheckConnection();

src/Runner.Common/JobServerQueue.cs

@@ -20,6 +20,7 @@ namespace GitHub.Runner.Common
         void Start(Pipelines.AgentJobRequestMessage jobRequest);
         void QueueWebConsoleLine(Guid stepRecordId, string line, long? lineNumber = null);
         void QueueFileUpload(Guid timelineId, Guid timelineRecordId, string type, string name, string path, bool deleteSource);
+        void QueueSummaryUpload(Guid stepRecordId, string name, string path, bool deleteSource);
         void QueueTimelineRecordUpdate(Guid timelineId, TimelineRecord timelineRecord);
     }
 
@@ -30,6 +31,7 @@ namespace GitHub.Runner.Common
         private static readonly TimeSpan _delayForWebConsoleLineDequeue = TimeSpan.FromMilliseconds(500);
         private static readonly TimeSpan _delayForTimelineUpdateDequeue = TimeSpan.FromMilliseconds(500);
         private static readonly TimeSpan _delayForFileUploadDequeue = TimeSpan.FromMilliseconds(1000);
+        private static readonly TimeSpan _delayForSummaryUploadDequeue = TimeSpan.FromMilliseconds(1000);
 
         // Job message information
         private Guid _scopeIdentifier;
@@ -39,30 +41,33 @@ namespace GitHub.Runner.Common
         private Guid _jobTimelineRecordId;
 
         // queue for web console line
-        private readonly ConcurrentQueue<ConsoleLineInfo> _webConsoleLineQueue = new ConcurrentQueue<ConsoleLineInfo>();
+        private readonly ConcurrentQueue<ConsoleLineInfo> _webConsoleLineQueue = new();
 
         // queue for file upload (log file or attachment)
-        private readonly ConcurrentQueue<UploadFileInfo> _fileUploadQueue = new ConcurrentQueue<UploadFileInfo>();
+        private readonly ConcurrentQueue<UploadFileInfo> _fileUploadQueue = new();
+
+        private readonly ConcurrentQueue<SummaryUploadFileInfo> _summaryFileUploadQueue = new();
 
         // queue for timeline or timeline record update (one queue per timeline)
-        private readonly ConcurrentDictionary<Guid, ConcurrentQueue<TimelineRecord>> _timelineUpdateQueue = new ConcurrentDictionary<Guid, ConcurrentQueue<TimelineRecord>>();
+        private readonly ConcurrentDictionary<Guid, ConcurrentQueue<TimelineRecord>> _timelineUpdateQueue = new();
 
         // indicate how many timelines we have, we will process _timelineUpdateQueue base on the order of timeline in this list
-        private readonly List<Guid> _allTimelines = new List<Guid>();
+        private readonly List<Guid> _allTimelines = new();
 
         // bufferd timeline records that fail to update
-        private readonly Dictionary<Guid, List<TimelineRecord>> _bufferedRetryRecords = new Dictionary<Guid, List<TimelineRecord>>();
+        private readonly Dictionary<Guid, List<TimelineRecord>> _bufferedRetryRecords = new();
 
         // Task for each queue's dequeue process
         private Task _webConsoleLineDequeueTask;
         private Task _fileUploadDequeueTask;
+        private Task _summaryUploadDequeueTask;
         private Task _timelineUpdateDequeueTask;
 
         // common
         private IJobServer _jobServer;
         private Task[] _allDequeueTasks;
-        private readonly TaskCompletionSource<int> _jobCompletionSource = new TaskCompletionSource<int>();
-        private readonly TaskCompletionSource<int> _jobRecordUpdated = new TaskCompletionSource<int>();
+        private readonly TaskCompletionSource<int> _jobCompletionSource = new();
+        private readonly TaskCompletionSource<int> _jobRecordUpdated = new();
         private bool _queueInProcess = false;
 
         public TaskCompletionSource<int> JobRecordUpdated => _jobRecordUpdated;
@@ -93,6 +98,20 @@ namespace GitHub.Runner.Common
 
             _jobServer.InitializeWebsocketClient(serviceEndPoint);
 
+            // This code is usually wrapped by an instance of IExecutionContext which isn't available here.
+            jobRequest.Variables.TryGetValue("system.github.results_endpoint", out VariableValue resultsEndpointVariable);
+            var resultsReceiverEndpoint = resultsEndpointVariable?.Value;
+
+            if (serviceEndPoint?.Authorization != null &&
+                serviceEndPoint.Authorization.Parameters.TryGetValue("AccessToken", out var accessToken) &&
+                !string.IsNullOrEmpty(accessToken) &&
+                !string.IsNullOrEmpty(resultsReceiverEndpoint))
+            {
+                Trace.Info("Initializing results client");
+                _jobServer.InitializeResultsClient(new Uri(resultsReceiverEndpoint), accessToken);
+            }
+
+
             if (_queueInProcess)
             {
                 Trace.Info("No-opt, all queue process tasks are running.");
@@ -120,10 +139,13 @@ namespace GitHub.Runner.Common
             Trace.Info("Start process file upload queue.");
             _fileUploadDequeueTask = ProcessFilesUploadQueueAsync();
 
+            Trace.Info("Start results file upload queue.");
+            _summaryUploadDequeueTask = ProcessSummaryUploadQueueAsync();
+
             Trace.Info("Start process timeline update queue.");
             _timelineUpdateDequeueTask = ProcessTimelinesUpdateQueueAsync();
 
-            _allDequeueTasks = new Task[] { _webConsoleLineDequeueTask, _fileUploadDequeueTask, _timelineUpdateDequeueTask };
+            _allDequeueTasks = new Task[] { _webConsoleLineDequeueTask, _fileUploadDequeueTask, _timelineUpdateDequeueTask, _summaryUploadDequeueTask };
             _queueInProcess = true;
         }
 
@@ -154,6 +176,10 @@ namespace GitHub.Runner.Common
             await ProcessFilesUploadQueueAsync(runOnce: true);
             Trace.Info("File upload queue drained.");
 
+            Trace.Verbose("Draining results summary upload queue.");
+            await ProcessSummaryUploadQueueAsync(runOnce: true);
+            Trace.Info("Results summary upload queue drained.");
+
             // ProcessTimelinesUpdateQueueAsync() will throw exception during shutdown
             // if there is any timeline records that failed to update contains output variabls.
             Trace.Verbose("Draining timeline update queue.");
@@ -204,6 +230,23 @@ namespace GitHub.Runner.Common
             _fileUploadQueue.Enqueue(newFile);
         }
 
+        public void QueueSummaryUpload(Guid stepRecordId, string name, string path, bool deleteSource)
+        {
+            // all parameter not null, file path exist.
+            var newFile = new SummaryUploadFileInfo()
+            {
+                Name = name,
+                Path = path,
+                PlanId = _planId.ToString(),
+                JobId = _jobTimelineRecordId.ToString(),
+                StepId = stepRecordId.ToString(),
+                DeleteSource = deleteSource
+            };
+
+            Trace.Verbose("Enqueue results file upload queue: file '{0}' attach to job {1} step {2}", newFile.Path, _jobTimelineRecordId, stepRecordId);
+            _summaryFileUploadQueue.Enqueue(newFile);
+        }
+
         public void QueueTimelineRecordUpdate(Guid timelineId, TimelineRecord timelineRecord)
         {
             ArgUtil.NotEmpty(timelineId, nameof(timelineId));
@@ -237,8 +280,8 @@ namespace GitHub.Runner.Common
                 }
 
                 // Group consolelines by timeline record of each step
-                Dictionary<Guid, List<TimelineRecordLogLine>> stepsConsoleLines = new Dictionary<Guid, List<TimelineRecordLogLine>>();
-                List<Guid> stepRecordIds = new List<Guid>(); // We need to keep lines in order
+                Dictionary<Guid, List<TimelineRecordLogLine>> stepsConsoleLines = new();
+                List<Guid> stepRecordIds = new(); // We need to keep lines in order
                 int linesCounter = 0;
                 ConsoleLineInfo lineInfo;
                 while (_webConsoleLineQueue.TryDequeue(out lineInfo))
@@ -264,7 +307,7 @@ namespace GitHub.Runner.Common
                 {
                     // Split consolelines into batch, each batch will container at most 100 lines.
                     int batchCounter = 0;
-                    List<List<TimelineRecordLogLine>> batchedLines = new List<List<TimelineRecordLogLine>>();
+                    List<List<TimelineRecordLogLine>> batchedLines = new();
                     foreach (var line in stepsConsoleLines[stepRecordId])
                     {
                         var currentBatch = batchedLines.ElementAtOrDefault(batchCounter);
@@ -338,7 +381,7 @@ namespace GitHub.Runner.Common
         {
             while (!_jobCompletionSource.Task.IsCompleted || runOnce)
             {
-                List<UploadFileInfo> filesToUpload = new List<UploadFileInfo>();
+                List<UploadFileInfo> filesToUpload = new();
                 UploadFileInfo dequeueFile;
                 while (_fileUploadQueue.TryDequeue(out dequeueFile))
                 {
@@ -394,17 +437,84 @@ namespace GitHub.Runner.Common
             }
         }
 
+        private async Task ProcessSummaryUploadQueueAsync(bool runOnce = false)
+        {
+            Trace.Info("Starting results-based upload queue...");
+
+            while (!_jobCompletionSource.Task.IsCompleted || runOnce)
+            {
+                List<SummaryUploadFileInfo> filesToUpload = new();
+                SummaryUploadFileInfo dequeueFile;
+                while (_summaryFileUploadQueue.TryDequeue(out dequeueFile))
+                {
+                    filesToUpload.Add(dequeueFile);
+                    // process at most 10 file upload.
+                    if (!runOnce && filesToUpload.Count > 10)
+                    {
+                        break;
+                    }
+                }
+
+                if (filesToUpload.Count > 0)
+                {
+                    if (runOnce)
+                    {
+                        Trace.Info($"Uploading {filesToUpload.Count} summary files in one shot through results service.");
+                    }
+
+                    int errorCount = 0;
+                    foreach (var file in filesToUpload)
+                    {
+                        try
+                        {
+                            await UploadSummaryFile(file);
+                        }
+                        catch (Exception ex)
+                        {
+                            var issue = new Issue() { Type = IssueType.Warning, Message = $"Caught exception during summary file upload to results. {ex.Message}" };
+                            issue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.ResultsUploadFailure;
+
+                            var telemetryRecord = new TimelineRecord()
+                            {
+                                Id = Constants.Runner.TelemetryRecordId,
+                            };
+                            telemetryRecord.Issues.Add(issue);
+                            QueueTimelineRecordUpdate(_jobTimelineId, telemetryRecord);
+
+                            Trace.Info("Catch exception during summary file upload to results, keep going since the process is best effort.");
+                            Trace.Error(ex);
+                        }
+                        finally
+                        {
+                            errorCount++;
+                        }
+                    }
+
+                    Trace.Info("Tried to upload {0} summary files to results, success rate: {1}/{0}.", filesToUpload.Count, filesToUpload.Count - errorCount);
+                }
+
+                if (runOnce)
+                {
+                    break;
+                }
+                else
+                {
+                    await Task.Delay(_delayForSummaryUploadDequeue);
+                }
+            }
+        }
+
         private async Task ProcessTimelinesUpdateQueueAsync(bool runOnce = false)
         {
             while (!_jobCompletionSource.Task.IsCompleted || runOnce)
             {
-                List<PendingTimelineRecord> pendingUpdates = new List<PendingTimelineRecord>();
+                List<PendingTimelineRecord> pendingUpdates = new();
                 foreach (var timeline in _allTimelines)
                 {
                     ConcurrentQueue<TimelineRecord> recordQueue;
                     if (_timelineUpdateQueue.TryGetValue(timeline, out recordQueue))
                     {
-                        List<TimelineRecord> records = new List<TimelineRecord>();
+                        List<TimelineRecord> records = new();
                         TimelineRecord record;
                         while (recordQueue.TryDequeue(out record))
                         {
@@ -426,7 +536,7 @@ namespace GitHub.Runner.Common
                 // we need track whether we have new sub-timeline been created on the last run.
                 // if so, we need continue update timeline record even we on the last run.
                 bool pendingSubtimelineUpdate = false;
-                List<Exception> mainTimelineRecordsUpdateErrors = new List<Exception>();
+                List<Exception> mainTimelineRecordsUpdateErrors = new();
                 if (pendingUpdates.Count > 0)
                 {
                     foreach (var update in pendingUpdates)
@@ -529,7 +639,7 @@ namespace GitHub.Runner.Common
                 return timelineRecords;
             }
 
-            Dictionary<Guid, TimelineRecord> dict = new Dictionary<Guid, TimelineRecord>();
+            Dictionary<Guid, TimelineRecord> dict = new();
             foreach (TimelineRecord rec in timelineRecords)
             {
                 if (rec == null)
@@ -665,6 +775,35 @@ namespace GitHub.Runner.Common
                 }
             }
         }
+
+        private async Task UploadSummaryFile(SummaryUploadFileInfo file)
+        {
+            bool uploadSucceed = false;
+            try
+            {
+                // Upload the step summary
+                Trace.Info($"Starting to upload summary file to results service {file.Name}, {file.Path}");
+                var cancellationTokenSource = new CancellationTokenSource();
+                await _jobServer.CreateStepSymmaryAsync(file.PlanId, file.JobId, file.StepId, file.Path, cancellationTokenSource.Token);
+
+                uploadSucceed = true;
+            }
+            finally
+            {
+                if (uploadSucceed && file.DeleteSource)
+                {
+                    try
+                    {
+                        File.Delete(file.Path);
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Info("Catch exception during delete success results uploaded summary file.");
+                        Trace.Error(ex);
+                    }
+                }
+            }
+        }
     }
 
     internal class PendingTimelineRecord
@@ -683,6 +822,17 @@ namespace GitHub.Runner.Common
         public bool DeleteSource { get; set; }
     }
 
+    internal class SummaryUploadFileInfo
+    {
+        public string Name { get; set; }
+        public string Path { get; set; }
+        public string PlanId { get; set; }
+        public string JobId { get; set; }
+        public string StepId { get; set; }
+        public bool DeleteSource { get; set; }
+    }
+
+
 
     internal class ConsoleLineInfo
     {

src/Runner.Common/ProcessChannel.cs

@@ -76,7 +76,7 @@ namespace GitHub.Runner.Common
 
         public async Task<WorkerMessage> ReceiveAsync(CancellationToken cancellationToken)
         {
-            WorkerMessage result = new WorkerMessage(MessageType.NotInitialized, string.Empty);
+            WorkerMessage result = new(MessageType.NotInitialized, string.Empty);
             result.MessageType = (MessageType)await _readStream.ReadInt32Async(cancellationToken);
             result.Body = await _readStream.ReadStringAsync(cancellationToken);
             Trace.Info($"Receiving message of length {result.Body.Length}, with hash '{IOUtil.GetSha256Hash(result.Body)}'");

src/Runner.Common/ProcessExtensions.cs

@@ -291,7 +291,7 @@ namespace GitHub.Runner.Common
         public static string GetEnvironmentVariable(this Process process, IHostContext hostContext, string variable)
         {
             var trace = hostContext.GetTrace(nameof(LinuxProcessExtensions));
-            Dictionary<string, string> env = new Dictionary<string, string>();
+            Dictionary<string, string> env = new();
 
             if (Directory.Exists("/proc"))
             {
@@ -322,8 +322,8 @@ namespace GitHub.Runner.Common
                 // It doesn't escape '=' or ' ', so we can't parse the output into a dictionary of all envs.
                 // So we only look for the env you request, in the format of variable=value. (it won't work if you variable contains = or space)
                 trace.Info($"Read env from output of `ps e -p {process.Id} -o command`");
-                List<string> psOut = new List<string>();
-                object outputLock = new object();
+                List<string> psOut = new();
+                object outputLock = new();
                 using (var p = hostContext.CreateService<IProcessInvoker>())
                 {
                     p.OutputDataReceived += delegate (object sender, ProcessDataReceivedEventArgs stdout)

src/Runner.Common/RunServer.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.Pipelines;
@@ -6,6 +6,7 @@ using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using GitHub.Services.WebApi;
+using Sdk.WebApi.WebApi.RawClient;
 
 namespace GitHub.Runner.Common
 {
@@ -20,42 +21,19 @@ namespace GitHub.Runner.Common
     public sealed class RunServer : RunnerService, IRunServer
     {
         private bool _hasConnection;
-        private VssConnection _connection;
-        private TaskAgentHttpClient _taskAgentClient;
+        private Uri requestUri;
+        private RawConnection _connection;
+        private RunServiceHttpClient _runServiceHttpClient;
 
-        public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
+        public async Task ConnectAsync(Uri serverUri, VssCredentials credentials)
         {
-            _connection = await EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
-            _taskAgentClient = _connection.GetClient<TaskAgentHttpClient>();
+            requestUri = serverUri;
+
+            _connection = VssUtil.CreateRawConnection(new Uri(serverUri.Authority), credentials);
+            _runServiceHttpClient = await _connection.GetClientAsync<RunServiceHttpClient>();
             _hasConnection = true;
         }
 
-        private async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
-        {
-            Trace.Info($"EstablishVssConnection");
-            Trace.Info($"Establish connection with {timeout.TotalSeconds} seconds timeout.");
-            int attemptCount = 5;
-            while (attemptCount-- > 0)
-            {
-                var connection = VssUtil.CreateConnection(serverUrl, credentials, timeout: timeout);
-                try
-                {
-                    await connection.ConnectAsync();
-                    return connection;
-                }
-                catch (Exception ex) when (attemptCount > 0)
-                {
-                    Trace.Info($"Catch exception during connect. {attemptCount} attempt left.");
-                    Trace.Error(ex);
-
-                    await HostContext.Delay(TimeSpan.FromMilliseconds(100), CancellationToken.None);
-                }
-            }
-
-            // should never reach here.
-            throw new InvalidOperationException(nameof(EstablishVssConnection));
-        }
-
         private void CheckConnection()
         {
             if (!_hasConnection)
@@ -67,37 +45,15 @@ namespace GitHub.Runner.Common
         public Task<AgentJobRequestMessage> GetJobMessageAsync(string id, CancellationToken cancellationToken)
         {
             CheckConnection();
-            var jobMessage = RetryRequest<AgentJobRequestMessage>(async () =>
+            var jobMessage = RetryRequest<AgentJobRequestMessage>(
+                async () => await _runServiceHttpClient.GetJobMessageAsync(requestUri, id, cancellationToken), cancellationToken);
+            if (jobMessage == null)
             {
-                                                        return await _taskAgentClient.GetJobMessageAsync(id, cancellationToken);
-                                                    }, cancellationToken);
+                throw new TaskOrchestrationJobNotFoundException(id);
+            }
+
             return jobMessage;
         }
 
-        private async Task<T> RetryRequest<T>(Func<Task<T>> func,
-                                              CancellationToken cancellationToken,
-                                              int maxRetryAttemptsCount = 5
-                                             )
-        {
-            var retryCount = 0;
-            while (true)
-            {
-                retryCount++;
-                cancellationToken.ThrowIfCancellationRequested();
-                try
-                {
-                    return await func();
-                }
-                // TODO: Add handling of non-retriable exceptions: https://github.com/github/actions-broker/issues/122
-                catch (Exception ex) when (retryCount < maxRetryAttemptsCount)
-                {
-                    Trace.Error("Catch exception during get full job message");
-                    Trace.Error(ex);
-                    var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15));
-                    Trace.Warning($"Back off {backOff.TotalSeconds} seconds before next retry. {maxRetryAttemptsCount - retryCount} attempt left.");
-                    await Task.Delay(backOff, cancellationToken);
-                }
-            }
-        }
     }
 }

src/Runner.Common/RunnerServer.cs

@@ -38,7 +38,7 @@ namespace GitHub.Runner.Common
         Task<TaskAgentSession> CreateAgentSessionAsync(Int32 poolId, TaskAgentSession session, CancellationToken cancellationToken);
         Task DeleteAgentMessageAsync(Int32 poolId, Int64 messageId, Guid sessionId, CancellationToken cancellationToken);
         Task DeleteAgentSessionAsync(Int32 poolId, Guid sessionId, CancellationToken cancellationToken);
-        Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, TaskAgentStatus status, CancellationToken cancellationToken);
+        Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, TaskAgentStatus status, string runnerVersion, CancellationToken cancellationToken);
 
         // job request
         Task<TaskAgentJobRequest> GetAgentRequestAsync(int poolId, long requestId, CancellationToken cancellationToken);
@@ -179,31 +179,6 @@ namespace GitHub.Runner.Common
             }
         }
 
-        private async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
-        {
-            Trace.Info($"Establish connection with {timeout.TotalSeconds} seconds timeout.");
-            int attemptCount = 5;
-            while (attemptCount-- > 0)
-            {
-                var connection = VssUtil.CreateConnection(serverUrl, credentials, timeout: timeout);
-                try
-                {
-                    await connection.ConnectAsync();
-                    return connection;
-                }
-                catch (Exception ex) when (attemptCount > 0)
-                {
-                    Trace.Info($"Catch exception during connect. {attemptCount} attempt left.");
-                    Trace.Error(ex);
-
-                    await HostContext.Delay(TimeSpan.FromMilliseconds(100), CancellationToken.None);
-                }
-            }
-
-            // should never reach here.
-            throw new InvalidOperationException(nameof(EstablishVssConnection));
-        }
-
         private void CheckConnection(RunnerConnectionType connectionType)
         {
             switch (connectionType)
@@ -297,10 +272,10 @@ namespace GitHub.Runner.Common
             return _messageTaskAgentClient.DeleteAgentSessionAsync(poolId, sessionId, cancellationToken: cancellationToken);
         }
 
-        public Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, TaskAgentStatus status, CancellationToken cancellationToken)
+        public Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, TaskAgentStatus status, string runnerVersion, CancellationToken cancellationToken)
         {
             CheckConnection(RunnerConnectionType.MessageQueue);
-            return _messageTaskAgentClient.GetMessageAsync(poolId, sessionId, lastMessageId, status, cancellationToken: cancellationToken);
+            return _messageTaskAgentClient.GetMessageAsync(poolId, sessionId, lastMessageId, status, runnerVersion, cancellationToken: cancellationToken);
         }
 
         //-----------------------------------------------------------------

src/Runner.Common/RunnerService.cs

@@ -1,4 +1,10 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.Runner.Sdk;
+using GitHub.Services.Common;
+using GitHub.Services.WebApi;
+using Sdk.WebApi.WebApi.RawClient;
 
 namespace GitHub.Runner.Common
 {
@@ -35,5 +41,57 @@ namespace GitHub.Runner.Common
             Trace = HostContext.GetTrace(TraceName);
             Trace.Entering();
         }
+
+        protected async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
+        {
+            Trace.Info($"EstablishVssConnection");
+            Trace.Info($"Establish connection with {timeout.TotalSeconds} seconds timeout.");
+            int attemptCount = 5;
+            while (attemptCount-- > 0)
+            {
+                var connection = VssUtil.CreateConnection(serverUrl, credentials, timeout: timeout);
+                try
+                {
+                    await connection.ConnectAsync();
+                    return connection;
+                }
+                catch (Exception ex) when (attemptCount > 0)
+                {
+                    Trace.Info($"Catch exception during connect. {attemptCount} attempt left.");
+                    Trace.Error(ex);
+
+                    await HostContext.Delay(TimeSpan.FromMilliseconds(100), CancellationToken.None);
+                }
+            }
+
+            // should never reach here.
+            throw new InvalidOperationException(nameof(EstablishVssConnection));
+        }
+
+        protected async Task<T> RetryRequest<T>(Func<Task<T>> func,
+            CancellationToken cancellationToken,
+            int maxRetryAttemptsCount = 5
+        )
+        {
+            var retryCount = 0;
+            while (true)
+            {
+                retryCount++;
+                cancellationToken.ThrowIfCancellationRequested();
+                try
+                {
+                    return await func();
+                }
+                // TODO: Add handling of non-retriable exceptions: https://github.com/github/actions-broker/issues/122
+                catch (Exception ex) when (retryCount < maxRetryAttemptsCount)
+                {
+                    Trace.Error("Catch exception during get full job message");
+                    Trace.Error(ex);
+                    var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15));
+                    Trace.Warning($"Back off {backOff.TotalSeconds} seconds before next retry. {maxRetryAttemptsCount - retryCount} attempt left.");
+                    await Task.Delay(backOff, cancellationToken);
+                }
+            }
+        }
     }
 }

src/Runner.Common/StdoutTraceListener.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using GitHub.Runner.Sdk;
+
+namespace GitHub.Runner.Common
+{
+    public sealed class StdoutTraceListener : ConsoleTraceListener
+    {
+        private readonly string _hostType;
+
+        public StdoutTraceListener(string hostType)
+        {
+            this._hostType = hostType;
+        }
+
+        // Copied and modified slightly from .Net Core source code. Modification was required to make it compile.
+        // There must be some TraceFilter extension class that is missing in this source code.
+        public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
+        {
+            if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
+            {
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(message))
+            {
+                var messageLines = message.Split(Environment.NewLine);
+                foreach (var messageLine in messageLines)
+                {
+                    WriteHeader(source, eventType, id);
+                    WriteLine(messageLine);
+                    WriteFooter(eventCache);
+                }
+            }
+        }
+
+        internal bool IsEnabled(TraceOptions opts)
+        {
+            return (opts & TraceOutputOptions) != 0;
+        }
+
+        // Altered from the original .Net Core implementation.
+        private void WriteHeader(string source, TraceEventType eventType, int id)
+        {
+            string type = null;
+            switch (eventType)
+            {
+                case TraceEventType.Critical:
+                    type = "CRIT";
+                    break;
+                case TraceEventType.Error:
+                    type = "ERR ";
+                    break;
+                case TraceEventType.Warning:
+                    type = "WARN";
+                    break;
+                case TraceEventType.Information:
+                    type = "INFO";
+                    break;
+                case TraceEventType.Verbose:
+                    type = "VERB";
+                    break;
+                default:
+                    type = eventType.ToString();
+                    break;
+            }
+
+            Write(StringUtil.Format("[{0} {1:u} {2} {3}] ", _hostType.ToUpperInvariant(), DateTime.UtcNow, type, source));
+        }
+
+        // Copied and modified slightly from .Net Core source code to make it compile. The original code
+        // accesses a private indentLevel field. In this code it has been modified to use the getter/setter.
+        private void WriteFooter(TraceEventCache eventCache)
+        {
+            if (eventCache == null)
+                return;
+
+            IndentLevel++;
+            if (IsEnabled(TraceOptions.ProcessId))
+                WriteLine("ProcessId=" + eventCache.ProcessId);
+
+            if (IsEnabled(TraceOptions.ThreadId))
+                WriteLine("ThreadId=" + eventCache.ThreadId);
+
+            if (IsEnabled(TraceOptions.DateTime))
+                WriteLine("DateTime=" + eventCache.DateTime.ToString("o", CultureInfo.InvariantCulture));
+
+            if (IsEnabled(TraceOptions.Timestamp))
+                WriteLine("Timestamp=" + eventCache.Timestamp);
+
+            IndentLevel--;
+        }
+    }
+}

src/Runner.Common/Terminal.cs

@@ -18,7 +18,7 @@ namespace GitHub.Runner.Common
         string ReadSecret();
         void Write(string message, ConsoleColor? colorCode = null);
         void WriteLine();
-        void WriteLine(string line, ConsoleColor? colorCode = null);
+        void WriteLine(string line, ConsoleColor? colorCode = null, bool skipTracing = false);
         void WriteError(Exception ex);
         void WriteError(string line);
         void WriteSection(string message);
@@ -81,7 +81,7 @@ namespace GitHub.Runner.Common
             }
 
             // Trace whether a value was entered.
-            string val = new String(chars.ToArray());
+            string val = new(chars.ToArray());
             if (!string.IsNullOrEmpty(val))
             {
                 HostContext.SecretMasker.AddValue(val);
@@ -116,9 +116,12 @@ namespace GitHub.Runner.Common
 
         // Do not add a format string overload. Terminal messages are user facing and therefore
         // should be localized. Use the Loc method in the StringUtil class.
-        public void WriteLine(string line, ConsoleColor? colorCode = null)
+        public void WriteLine(string line, ConsoleColor? colorCode = null, bool skipTracing = false)
+        {
+            if (!skipTracing)
             {
                 Trace.Info($"WRITE LINE: {line}");
+            }
             if (!Silent)
             {
                 if (colorCode != null)

src/Runner.Common/TraceManager.cs

@@ -14,23 +14,25 @@ namespace GitHub.Runner.Common
 
     public sealed class TraceManager : ITraceManager
     {
-        private readonly ConcurrentDictionary<string, Tracing> _sources = new ConcurrentDictionary<string, Tracing>(StringComparer.OrdinalIgnoreCase);
+        private readonly ConcurrentDictionary<string, Tracing> _sources = new(StringComparer.OrdinalIgnoreCase);
         private readonly HostTraceListener _hostTraceListener;
+        private readonly StdoutTraceListener _stdoutTraceListener;
         private TraceSetting _traceSetting;
         private ISecretMasker _secretMasker;
 
-        public TraceManager(HostTraceListener traceListener, ISecretMasker secretMasker)
-            : this(traceListener, new TraceSetting(), secretMasker)
+        public TraceManager(HostTraceListener traceListener, StdoutTraceListener stdoutTraceListener, ISecretMasker secretMasker)
+            : this(traceListener, stdoutTraceListener, new TraceSetting(), secretMasker)
         {
         }
 
-        public TraceManager(HostTraceListener traceListener, TraceSetting traceSetting, ISecretMasker secretMasker)
+        public TraceManager(HostTraceListener traceListener, StdoutTraceListener stdoutTraceListener, TraceSetting traceSetting, ISecretMasker secretMasker)
         {
             // Validate and store params.
             ArgUtil.NotNull(traceListener, nameof(traceListener));
             ArgUtil.NotNull(traceSetting, nameof(traceSetting));
             ArgUtil.NotNull(secretMasker, nameof(secretMasker));
             _hostTraceListener = traceListener;
+            _stdoutTraceListener = stdoutTraceListener;
             _traceSetting = traceSetting;
             _secretMasker = secretMasker;
 
@@ -81,7 +83,7 @@ namespace GitHub.Runner.Common
                     Level = sourceTraceLevel.ToSourceLevels()
                 };
             }
-            return new Tracing(name, _secretMasker, sourceSwitch, _hostTraceListener);
+            return new Tracing(name, _secretMasker, sourceSwitch, _hostTraceListener, _stdoutTraceListener);
         }
     }
 }

src/Runner.Common/Tracing.cs

@@ -12,7 +12,7 @@ namespace GitHub.Runner.Common
         private ISecretMasker _secretMasker;
         private TraceSource _traceSource;
 
-        public Tracing(string name, ISecretMasker secretMasker, SourceSwitch sourceSwitch, HostTraceListener traceListener)
+        public Tracing(string name, ISecretMasker secretMasker, SourceSwitch sourceSwitch, HostTraceListener traceListener, StdoutTraceListener stdoutTraceListener = null)
         {
             ArgUtil.NotNull(secretMasker, nameof(secretMasker));
             _secretMasker = secretMasker;
@@ -27,6 +27,10 @@ namespace GitHub.Runner.Common
             }
 
             _traceSource.Listeners.Add(traceListener);
+            if (stdoutTraceListener != null)
+            {
+                _traceSource.Listeners.Add(stdoutTraceListener);
+            }
         }
 
         public void Info(string message)

src/Runner.Listener/Checks/CheckUtil.cs

@@ -347,8 +347,8 @@ namespace GitHub.Runner.Listener.Check
     public sealed class HttpEventSourceListener : EventListener
     {
         private readonly List<string> _logs;
-        private readonly object _lock = new object();
-        private readonly Dictionary<string, HashSet<string>> _ignoredEvent = new Dictionary<string, HashSet<string>>
+        private readonly object _lock = new();
+        private readonly Dictionary<string, HashSet<string>> _ignoredEvent = new()
         {
             {
                 "Microsoft-System-Net-Http",

src/Runner.Listener/Checks/NodeJsCheck.cs

@@ -86,7 +86,7 @@ namespace GitHub.Runner.Listener.Check
                 result.Logs.Add($"{DateTime.UtcNow.ToString("O")} ***************************************************************************************************************");
 
                 // Request to github.com or ghes server
-                Uri requestUrl = new Uri(url);
+                Uri requestUrl = new(url);
                 var env = new Dictionary<string, string>()
                 {
                     { "HOSTNAME", requestUrl.Host },

src/Runner.Listener/CommandSettings.cs

@@ -11,7 +11,7 @@ namespace GitHub.Runner.Listener
 {
     public sealed class CommandSettings
     {
-        private readonly Dictionary<string, string> _envArgs = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, string> _envArgs = new(StringComparer.OrdinalIgnoreCase);
         private readonly CommandLineParser _parser;
         private readonly IPromptManager _promptManager;
         private readonly Tracing _trace;
@@ -26,7 +26,7 @@ namespace GitHub.Runner.Listener
         };
 
         // Valid flags and args for specific command - key: command, value: array of valid flags and args
-        private readonly Dictionary<string, string[]> validOptions = new Dictionary<string, string[]>
+        private readonly Dictionary<string, string[]> validOptions = new()
         {
             // Valid configure flags and args
             [Constants.Runner.CommandLine.Commands.Configure] = 
@@ -34,6 +34,7 @@ namespace GitHub.Runner.Listener
                 {
                     Constants.Runner.CommandLine.Flags.DisableUpdate,
                     Constants.Runner.CommandLine.Flags.Ephemeral,
+                    Constants.Runner.CommandLine.Flags.GenerateServiceConfig,
                     Constants.Runner.CommandLine.Flags.Replace,
                     Constants.Runner.CommandLine.Flags.RunAsService,
                     Constants.Runner.CommandLine.Flags.Unattended,
@@ -55,7 +56,8 @@ namespace GitHub.Runner.Listener
                 new string[]
                 {
                     Constants.Runner.CommandLine.Args.Token,
-                    Constants.Runner.CommandLine.Args.PAT
+                    Constants.Runner.CommandLine.Args.PAT,
+                    Constants.Runner.CommandLine.Flags.Local
                 },
             // Valid run flags and args
             [Constants.Runner.CommandLine.Commands.Run] =
@@ -79,11 +81,13 @@ namespace GitHub.Runner.Listener
         // Flags.
         public bool Check => TestFlag(Constants.Runner.CommandLine.Flags.Check);
         public bool Commit => TestFlag(Constants.Runner.CommandLine.Flags.Commit);
+        public bool DisableUpdate => TestFlag(Constants.Runner.CommandLine.Flags.DisableUpdate);
+        public bool Ephemeral => TestFlag(Constants.Runner.CommandLine.Flags.Ephemeral);
+        public bool GenerateServiceConfig => TestFlag(Constants.Runner.CommandLine.Flags.GenerateServiceConfig);
         public bool Help => TestFlag(Constants.Runner.CommandLine.Flags.Help);
         public bool Unattended => TestFlag(Constants.Runner.CommandLine.Flags.Unattended);
         public bool Version => TestFlag(Constants.Runner.CommandLine.Flags.Version);
-        public bool Ephemeral => TestFlag(Constants.Runner.CommandLine.Flags.Ephemeral);
-        public bool DisableUpdate => TestFlag(Constants.Runner.CommandLine.Flags.DisableUpdate);
+        public bool RemoveLocalConfig => TestFlag(Constants.Runner.CommandLine.Flags.Local);
 
         // Keep this around since customers still relies on it
         public bool RunOnce => TestFlag(Constants.Runner.CommandLine.Flags.Once);
@@ -137,7 +141,7 @@ namespace GitHub.Runner.Listener
         // Validate commandline parser result
         public List<string> Validate()
         {
-            List<string> unknowns = new List<string>();
+            List<string> unknowns = new();
 
             // detect unknown commands
             unknowns.AddRange(_parser.Commands.Where(x => !validOptions.Keys.Contains(x, StringComparer.OrdinalIgnoreCase)));

src/Runner.Listener/Configuration/ConfigurationManager.cs

@@ -1,10 +1,3 @@
-using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Common;
-using GitHub.Runner.Common.Util;
-using GitHub.Runner.Sdk;
-using GitHub.Services.Common;
-using GitHub.Services.Common.Internal;
-using GitHub.Services.OAuth;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,6 +7,13 @@ using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 using System.Text;
 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.Common.Internal;
+using GitHub.Services.OAuth;
 
 namespace GitHub.Runner.Listener.Configuration
 {
@@ -81,12 +81,33 @@ namespace GitHub.Runner.Listener.Configuration
             _term.WriteLine("--------------------------------------------------------------------------------");
 
             Trace.Info(nameof(ConfigureAsync));
+
+            if (command.GenerateServiceConfig)
+            {
+#if OS_LINUX
+                if (!IsConfigured())
+                {
+                    throw new InvalidOperationException("--generateServiceConfig requires that the runner is already configured. For configuring a new runner as a service, run './config.sh'.");
+                }
+
+                RunnerSettings settings = _store.GetSettings();
+
+                Trace.Info($"generate service config for runner: {settings.AgentId}");
+                var controlManager = HostContext.GetService<ILinuxServiceControlManager>();
+                controlManager.GenerateScripts(settings);
+
+                return;
+#else
+                throw new NotSupportedException("--generateServiceConfig is only supported on Linux.");
+#endif
+            }
+
             if (IsConfigured())
             {
                 throw new InvalidOperationException("Cannot configure the runner because it is already configured. To reconfigure the runner, run 'config.cmd remove' or './config.sh remove' first.");
             }
 
-            RunnerSettings runnerSettings = new RunnerSettings();
+            RunnerSettings runnerSettings = new();
 
             // Loop getting url and creds until you can connect
             ICredentialProvider credProvider = null;
@@ -521,7 +542,7 @@ namespace GitHub.Runner.Listener.Configuration
 
         private TaskAgent CreateNewAgent(string agentName, RSAParameters publicKey, ISet<string> userLabels, bool ephemeral, bool disableUpdate)
         {
-            TaskAgent agent = new TaskAgent(agentName)
+            TaskAgent agent = new(agentName)
             {
                 Authorization = new TaskAgentAuthorization
                 {
@@ -615,7 +636,7 @@ namespace GitHub.Runner.Listener.Configuration
             }
 
             int retryCount = 0;
-            while(retryCount < 3)
+            while (retryCount < 3)
             {
                 using (var httpClientHandler = HostContext.CreateHttpClientHandler())
                 using (var httpClient = new HttpClient(httpClientHandler))
@@ -631,22 +652,23 @@ namespace GitHub.Runner.Listener.Configuration
                     {
                         var response = await httpClient.PostAsync(githubApiUrl, new StringContent(string.Empty));
                         responseStatus = response.StatusCode;
+                        var githubRequestId = GetGitHubRequestId(response.Headers);
 
                         if (response.IsSuccessStatusCode)
                         {
-                            Trace.Info($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
+                            Trace.Info($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}' ({githubRequestId})");
                             var jsonResponse = await response.Content.ReadAsStringAsync();
                             return StringUtil.ConvertFromJson<GitHubRunnerRegisterToken>(jsonResponse);
                         }
                         else
                         {
-                            _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
+                            _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}' (Request Id: {githubRequestId})");
                             var errorResponse = await response.Content.ReadAsStringAsync();
                             _term.WriteError(errorResponse);
                             response.EnsureSuccessStatusCode();
                         }
                     }
-                    catch(Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
+                    catch (Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
                     {
                         retryCount++;
                         Trace.Error($"Failed to get JIT runner token -- Atempt: {retryCount}");
@@ -693,22 +715,23 @@ namespace GitHub.Runner.Listener.Configuration
                     {
                         var response = await httpClient.PostAsync(githubApiUrl, new StringContent(StringUtil.ConvertToJson(bodyObject), null, "application/json"));
                         responseStatus = response.StatusCode;
+                        var githubRequestId = GetGitHubRequestId(response.Headers);
 
-                        if(response.IsSuccessStatusCode)
+                        if (response.IsSuccessStatusCode)
                         {
-                            Trace.Info($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
+                            Trace.Info($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}' ({githubRequestId})");
                             var jsonResponse = await response.Content.ReadAsStringAsync();
                             return StringUtil.ConvertFromJson<GitHubAuthResult>(jsonResponse);
                         }
                         else
                         {
-                            _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
+                            _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}' (Request Id: {githubRequestId})");
                             var errorResponse = await response.Content.ReadAsStringAsync();
                             _term.WriteError(errorResponse);
                             response.EnsureSuccessStatusCode();
                         }
                     }
-                    catch(Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
+                    catch (Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
                     {
                         retryCount++;
                         Trace.Error($"Failed to get tenant credentials -- Atempt: {retryCount}");
@@ -721,5 +744,14 @@ namespace GitHub.Runner.Listener.Configuration
             }
             return null;
         }
+
+        private string GetGitHubRequestId(HttpResponseHeaders headers)
+        {
+            if (headers.TryGetValues("x-github-request-id", out var headerValues))
+            {
+                return headerValues.FirstOrDefault();
+            }
+            return string.Empty;
+        }
     }
 }

src/Runner.Listener/Configuration/CredentialManager.cs

@@ -18,7 +18,7 @@ namespace GitHub.Runner.Listener.Configuration
 
     public class CredentialManager : RunnerService, ICredentialManager
     {
-        public static readonly Dictionary<string, Type> CredentialTypes = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
+        public static readonly Dictionary<string, Type> CredentialTypes = new(StringComparer.OrdinalIgnoreCase)
         {
             { Constants.Configuration.OAuth, typeof(OAuthCredential)},
             { Constants.Configuration.OAuthAccessToken, typeof(OAuthAccessTokenCredential)},

src/Runner.Listener/Configuration/CredentialProvider.cs

@@ -48,7 +48,7 @@ namespace GitHub.Runner.Listener.Configuration
             ArgUtil.NotNullOrEmpty(token, nameof(token));
 
             trace.Info("token retrieved: {0} chars", token.Length);
-            VssCredentials creds = new VssCredentials(new VssOAuthAccessTokenCredential(token), CredentialPromptType.DoNotPrompt);
+            VssCredentials creds = new(new VssOAuthAccessTokenCredential(token), CredentialPromptType.DoNotPrompt);
             trace.Info("cred created");
 
             return creds;

src/Runner.Listener/Configuration/ServiceControlManager.cs

@@ -44,7 +44,7 @@ namespace GitHub.Runner.Listener.Configuration
             }
 
             // For the service name, replace any characters outside of the alpha-numeric set and ".", "_", "-" with "-"
-            Regex regex = new Regex(@"[^0-9a-zA-Z._\-]");
+            Regex regex = new(@"[^0-9a-zA-Z._\-]");
             string repoOrOrgName = regex.Replace(settings.RepoOrOrgName, "-");
 
             serviceName = StringUtil.Format(serviceNamePattern, repoOrOrgName, settings.AgentName);

src/Runner.Listener/JobDispatcher.cs

@@ -37,8 +37,8 @@ namespace GitHub.Runner.Listener
     // and the server will not send another job while this one is still running.
     public sealed class JobDispatcher : RunnerService, IJobDispatcher
     {
-        private static Regex _invalidJsonRegex = new Regex(@"invalid\ Json\ at\ position\ '(\d+)':", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-        private readonly Lazy<Dictionary<long, TaskResult>> _localRunJobResult = new Lazy<Dictionary<long, TaskResult>>();
+        private static Regex _invalidJsonRegex = new(@"invalid\ Json\ at\ position\ '(\d+)':", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+        private readonly Lazy<Dictionary<long, TaskResult>> _localRunJobResult = new();
         private int _poolId;
 
         IConfigurationStore _configurationStore;
@@ -47,14 +47,14 @@ namespace GitHub.Runner.Listener
         private static readonly string _workerProcessName = $"Runner.Worker{IOUtil.ExeExtension}";
 
         // this is not thread-safe
-        private readonly Queue<Guid> _jobDispatchedQueue = new Queue<Guid>();
-        private readonly ConcurrentDictionary<Guid, WorkerDispatcher> _jobInfos = new ConcurrentDictionary<Guid, WorkerDispatcher>();
+        private readonly Queue<Guid> _jobDispatchedQueue = new();
+        private readonly ConcurrentDictionary<Guid, WorkerDispatcher> _jobInfos = new();
 
         // allow up to 30sec for any data to be transmitted over the process channel
         // timeout limit can be overwritten by environment GITHUB_ACTIONS_RUNNER_CHANNEL_TIMEOUT
         private TimeSpan _channelTimeout;
 
-        private TaskCompletionSource<bool> _runOnceJobCompleted = new TaskCompletionSource<bool>();
+        private TaskCompletionSource<bool> _runOnceJobCompleted = new();
 
         public event EventHandler<JobStatusEventArgs> JobStatus;
 
@@ -111,7 +111,7 @@ namespace GitHub.Runner.Listener
                 }
             }
 
-            WorkerDispatcher newDispatch = new WorkerDispatcher(jobRequestMessage.JobId, jobRequestMessage.RequestId);
+            WorkerDispatcher newDispatch = new(jobRequestMessage.JobId, jobRequestMessage.RequestId);
             if (runOnce)
             {
                 Trace.Info("Start dispatcher for one time used runner.");
@@ -357,7 +357,7 @@ namespace GitHub.Runner.Listener
                 term.WriteLine($"{DateTime.UtcNow:u}: Running job: {message.JobDisplayName}");
 
                 // first job request renew succeed.
-                TaskCompletionSource<int> firstJobRequestRenewed = new TaskCompletionSource<int>();
+                TaskCompletionSource<int> firstJobRequestRenewed = new();
                 var notification = HostContext.GetService<IJobNotification>();
 
                 // lock renew cancellation token.
@@ -398,8 +398,9 @@ namespace GitHub.Runner.Listener
                     HostContext.WritePerfCounter($"JobRequestRenewed_{requestId.ToString()}");
 
                     Task<int> workerProcessTask = null;
-                    object _outputLock = new object();
-                    List<string> workerOutput = new List<string>();
+                    object _outputLock = new();
+                    List<string> workerOutput = new();
+                    bool printToStdout = StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable(Constants.Variables.Agent.PrintLogToStdout));
                     using (var processChannel = HostContext.CreateService<IProcessChannel>())
                     using (var processInvoker = HostContext.CreateService<IProcessInvoker>())
                     {
@@ -420,9 +421,17 @@ namespace GitHub.Runner.Listener
                                         if (!string.IsNullOrEmpty(stdout.Data))
                                         {
                                             lock (_outputLock)
+                                            {
+                                                if (!stdout.Data.StartsWith("[WORKER"))
                                                 {
                                                     workerOutput.Add(stdout.Data);
                                                 }
+                                                
+                                                if (printToStdout)
+                                                {
+                                                    term.WriteLine(stdout.Data, skipTracing: true);
+                                                }
+                                            }
                                         }
                                     };
 
@@ -936,7 +945,7 @@ namespace GitHub.Runner.Listener
 
             var runnerServer = HostContext.GetService<IRunnerServer>();
             int completeJobRequestRetryLimit = 5;
-            List<Exception> exceptions = new List<Exception>();
+            List<Exception> exceptions = new();
             while (completeJobRequestRetryLimit-- > 0)
             {
                 try
@@ -1039,7 +1048,7 @@ namespace GitHub.Runner.Listener
             public Task WorkerDispatch { get; set; }
             public CancellationTokenSource WorkerCancellationTokenSource { get; private set; }
             public CancellationTokenSource WorkerCancelTimeoutKillTokenSource { get; private set; }
-            private readonly object _lock = new object();
+            private readonly object _lock = new();
 
             public WorkerDispatcher(Guid jobId, long requestId)
             {

src/Runner.Listener/MessageListener.cs

@@ -38,7 +38,7 @@ namespace GitHub.Runner.Listener
         private readonly TimeSpan _sessionCreationRetryInterval = TimeSpan.FromSeconds(30);
         private readonly TimeSpan _sessionConflictRetryLimit = TimeSpan.FromMinutes(4);
         private readonly TimeSpan _clockSkewRetryLimit = TimeSpan.FromMinutes(30);
-        private readonly Dictionary<string, int> _sessionCreationExceptionTracker = new Dictionary<string, int>();
+        private readonly Dictionary<string, int> _sessionCreationExceptionTracker = new();
         private TaskAgentStatus runnerStatus = TaskAgentStatus.Online;
         private CancellationTokenSource _getMessagesTokenSource;
 
@@ -198,7 +198,7 @@ namespace GitHub.Runner.Listener
             bool encounteringError = false;
             int continuousError = 0;
             string errorMessage = string.Empty;
-            Stopwatch heartbeat = new Stopwatch();
+            Stopwatch heartbeat = new();
             heartbeat.Restart();
             while (true)
             {
@@ -211,6 +211,7 @@ namespace GitHub.Runner.Listener
                                                                 _session.SessionId,
                                                                 _lastMessageId,
                                                                 runnerStatus,
+                                                                BuildConstants.RunnerPackage.Version,
                                                                 _getMessagesTokenSource.Token);
 
                     // Decrypt the message body if the session is using encryption

src/Runner.Listener/Program.cs

@@ -16,7 +16,7 @@ namespace GitHub.Runner.Listener
             // Add environment variables from .env file
             LoadAndSetEnv();
 
-            using (HostContext context = new HostContext("Runner"))
+            using (HostContext context = new("Runner"))
             {
                 return MainAsync(context, args).GetAwaiter().GetResult();
             }

src/Runner.Listener/Runner.cs

@@ -28,7 +28,7 @@ namespace GitHub.Runner.Listener
         private IMessageListener _listener;
         private ITerminal _term;
         private bool _inConfigStage;
-        private ManualResetEvent _completedCommand = new ManualResetEvent(false);
+        private ManualResetEvent _completedCommand = new(false);
 
         public override void Initialize(IHostContext hostContext)
         {
@@ -135,6 +135,12 @@ namespace GitHub.Runner.Listener
                 // remove config files, remove service, and exit
                 if (command.Remove)
                 {
+                    // only remove local config files and exit
+                    if(command.RemoveLocalConfig)
+                    {
+                        configManager.DeleteLocalRunnerConfig();
+                        return Constants.Runner.ReturnCode.Success;
+                    }
                     try
                     {
                         await configManager.UnconfigureAsync(command);
@@ -430,12 +436,22 @@ namespace GitHub.Runner.Listener
 
                             message = await getNextMessage; //get next message
                             HostContext.WritePerfCounter($"MessageReceived_{message.MessageType}");
-                            if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                            if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase) ||
+                                string.Equals(message.MessageType, RunnerRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
                             {
                                 if (autoUpdateInProgress == false)
                                 {
                                     autoUpdateInProgress = true;
-                                    var runnerUpdateMessage = JsonUtility.FromString<AgentRefreshMessage>(message.Body);
+                                    AgentRefreshMessage runnerUpdateMessage = null;
+                                    if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                                    {
+                                        runnerUpdateMessage = JsonUtility.FromString<AgentRefreshMessage>(message.Body);
+                                    }
+                                    else
+                                    {
+                                        var brokerRunnerUpdateMessage = JsonUtility.FromString<RunnerRefreshMessage>(message.Body);
+                                        runnerUpdateMessage = new AgentRefreshMessage(brokerRunnerUpdateMessage.RunnerId, brokerRunnerUpdateMessage.TargetVersion, TimeSpan.FromSeconds(brokerRunnerUpdateMessage.TimeoutInSeconds));
+                                    }
 #if DEBUG
                                     // Can mock the update for testing
                                     if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_IS_MOCK_UPDATE")))
@@ -496,16 +512,26 @@ namespace GitHub.Runner.Listener
                                 else
                                 {
                                     var messageRef = StringUtil.ConvertFromJson<RunnerJobRequestRef>(message.Body);
+                                    Pipelines.AgentJobRequestMessage jobRequestMessage = null;
 
                                     // Create connection
                                     var credMgr = HostContext.GetService<ICredentialManager>();
                                     var creds = credMgr.LoadCredentials();
 
+                                    if (string.IsNullOrEmpty(messageRef.RunServiceUrl))
+                                    {
+                                        var actionsRunServer = HostContext.CreateService<IActionsRunServer>();
+                                        await actionsRunServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
+                                        jobRequestMessage = await actionsRunServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
+                                    }
+                                    else
+                                    {
                                         var runServer = HostContext.CreateService<IRunServer>();
-                                    await runServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
-                                    var jobMessage = await runServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
+                                        await runServer.ConnectAsync(new Uri(messageRef.RunServiceUrl), creds);
+                                        jobRequestMessage = await runServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
+                                    }
 
-                                    jobDispatcher.Run(jobMessage, runOnce);
+                                    jobDispatcher.Run(jobRequestMessage, runOnce);
                                     if (runOnce)
                                     {
                                         Trace.Info("One time used runner received job message.");
@@ -627,6 +653,7 @@ Config Options:
  --name string          Name of the runner to configure (default {Environment.MachineName ?? "myrunner"})
  --runnergroup string   Name of the runner group to add this runner to (defaults to the default runner group)
  --labels string        Extra labels in addition to the default: 'self-hosted,{Constants.Runner.Platform},{Constants.Runner.PlatformArchitecture}'
+ --local                Removes the runner config files from your local machine. Used as an option to the remove command
  --work string          Relative runner work directory (default {Constants.Path.WorkDirectory})
  --replace              Replace any existing runner with the same name (default false)
  --pat                  GitHub personal access token with repo scope. Used for checking network connectivity when executing `.{separator}run.{ext} --check`

src/Runner.Listener/RunnerJobRequestRef.cs

@@ -9,5 +9,7 @@ namespace GitHub.Runner.Listener
         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; }
     }
 }

src/Runner.Listener/SelfUpdater.cs

@@ -32,14 +32,14 @@ namespace GitHub.Runner.Listener
         private static string _platform = BuildConstants.RunnerPackage.PackageName;
         private static string _dotnetRuntime = "dotnetRuntime";
         private static string _externals = "externals";
-        private readonly Dictionary<string, string> _contentHashes = new Dictionary<string, string>();
+        private readonly Dictionary<string, string> _contentHashes = new();
 
         private PackageMetadata _targetPackage;
         private ITerminal _terminal;
         private IRunnerServer _runnerServer;
         private int _poolId;
         private int _agentId;
-        private readonly ConcurrentQueue<string> _updateTrace = new ConcurrentQueue<string>();
+        private readonly ConcurrentQueue<string> _updateTrace = new();
         private Task _cloneAndCalculateContentHashTask;
         private string _dotnetRuntimeCloneDirectory;
         private string _externalsCloneDirectory;
@@ -134,7 +134,7 @@ namespace GitHub.Runner.Listener
                     string flagFile = "update.finished";
                     IOUtil.DeleteFile(flagFile);
                     // kick off update script
-                    Process invokeScript = new Process();
+                    Process invokeScript = new();
 #if OS_WINDOWS
                     invokeScript.StartInfo.FileName = WhichUtil.Which("cmd.exe", trace: Trace);
                     invokeScript.StartInfo.Arguments = $"/c \"{updateScript}\"";
@@ -191,9 +191,9 @@ namespace GitHub.Runner.Listener
             }
 
             Trace.Info($"Version '{_targetPackage.Version}' of '{_targetPackage.Type}' package available in server.");
-            PackageVersion serverVersion = new PackageVersion(_targetPackage.Version);
+            PackageVersion serverVersion = new(_targetPackage.Version);
             Trace.Info($"Current running runner version is {BuildConstants.RunnerPackage.Version}");
-            PackageVersion runnerVersion = new PackageVersion(BuildConstants.RunnerPackage.Version);
+            PackageVersion runnerVersion = new(BuildConstants.RunnerPackage.Version);
 
             return serverVersion.CompareTo(runnerVersion) > 0;
         }
@@ -476,7 +476,7 @@ namespace GitHub.Runner.Listener
                         long downloadSize = 0;
 
                         //open zip stream in async mode
-                        using (HttpClient httpClient = new HttpClient(HostContext.CreateHttpClientHandler()))
+                        using (HttpClient httpClient = new(HostContext.CreateHttpClientHandler()))
                         {
                             if (!string.IsNullOrEmpty(_targetPackage.Token))
                             {
@@ -486,7 +486,7 @@ namespace GitHub.Runner.Listener
 
                             Trace.Info($"Downloading {packageDownloadUrl}");
 
-                            using (FileStream fs = new FileStream(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true))
+                            using (FileStream fs = new(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true))
                             using (Stream result = await httpClient.GetStreamAsync(packageDownloadUrl))
                             {
                                 //81920 is the default used by System.IO.Stream.CopyTo and is under the large object heap threshold (85k).
@@ -596,7 +596,7 @@ namespace GitHub.Runner.Listener
                     int exitCode = await processInvoker.ExecuteAsync(extractDirectory, tar, $"-xzf \"{archiveFile}\"", null, token);
                     if (exitCode != 0)
                     {
-                        throw new NotSupportedException($"Can't use 'tar -xzf' extract archive file: {archiveFile}. return code: {exitCode}.");
+                        throw new NotSupportedException($"Can't use 'tar -xzf' to extract archive file: {archiveFile}. return code: {exitCode}.");
                     }
                 }
             }

src/Runner.PluginHost/Program.cs

@@ -12,7 +12,7 @@ namespace GitHub.Runner.PluginHost
 {
     public static class Program
     {
-        private static CancellationTokenSource tokenSource = new CancellationTokenSource();
+        private static CancellationTokenSource tokenSource = new();
         private static string executingAssemblyLocation = string.Empty;
 
         public static int Main(string[] args)

src/Runner.Plugins/Artifact/DownloadArtifact.cs

@@ -63,7 +63,7 @@ namespace GitHub.Runner.Plugins.Artifact
             string containerPath = actionsStorageArtifact.Name; // In actions storage artifacts, name equals the path
             long containerId = actionsStorageArtifact.ContainerId;
 
-            FileContainerServer fileContainerServer = new FileContainerServer(context.VssConnection, projectId: new Guid(), containerId, containerPath);
+            FileContainerServer fileContainerServer = new(context.VssConnection, projectId: new Guid(), containerId, containerPath);
             await fileContainerServer.DownloadFromContainerAsync(context, targetPath, token);
 
             context.Output("Artifact download finished.");

src/Runner.Plugins/Artifact/FileContainerServer.cs

@@ -23,10 +23,10 @@ namespace GitHub.Runner.Plugins.Artifact
         //81920 is the default used by System.IO.Stream.CopyTo and is under the large object heap threshold (85k). 
         private const int _defaultCopyBufferSize = 81920;
 
-        private readonly ConcurrentQueue<string> _fileUploadQueue = new ConcurrentQueue<string>();
-        private readonly ConcurrentQueue<DownloadInfo> _fileDownloadQueue = new ConcurrentQueue<DownloadInfo>();
-        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadTraceLog = new ConcurrentDictionary<string, ConcurrentQueue<string>>();
-        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadProgressLog = new ConcurrentDictionary<string, ConcurrentQueue<string>>();
+        private readonly ConcurrentQueue<string> _fileUploadQueue = new();
+        private readonly ConcurrentQueue<DownloadInfo> _fileDownloadQueue = new();
+        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadTraceLog = new();
+        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadProgressLog = new();
         private readonly FileContainerHttpClient _fileContainerHttpClient;
 
         private CancellationTokenSource _uploadCancellationTokenSource;
@@ -67,7 +67,7 @@ namespace GitHub.Runner.Plugins.Artifact
             CancellationToken cancellationToken)
         {
             // Find out all container items need to be processed
-            List<FileContainerItem> containerItems = new List<FileContainerItem>();
+            List<FileContainerItem> containerItems = new();
             int retryCount = 0;
             while (retryCount < 3)
             {
@@ -106,7 +106,7 @@ namespace GitHub.Runner.Plugins.Artifact
             // Create all required empty folders and emptry files, gather a list of files that we need to download from server.
             int foldersCreated = 0;
             int emptryFilesCreated = 0;
-            List<DownloadInfo> downloadFiles = new List<DownloadInfo>();
+            List<DownloadInfo> downloadFiles = new();
             foreach (var item in containerItems.OrderBy(x => x.Path))
             {
                 if (!item.Path.StartsWith(_containerPath, StringComparison.OrdinalIgnoreCase))
@@ -306,7 +306,7 @@ namespace GitHub.Runner.Plugins.Artifact
             Task downloadMonitor = DownloadReportingAsync(context, files.Count(), token);
 
             // Start parallel download tasks.
-            List<Task<DownloadResult>> parallelDownloadingTasks = new List<Task<DownloadResult>>();
+            List<Task<DownloadResult>> parallelDownloadingTasks = new();
             for (int downloader = 0; downloader < concurrentDownloads; downloader++)
             {
                 parallelDownloadingTasks.Add(DownloadAsync(context, downloader, token));
@@ -358,7 +358,7 @@ namespace GitHub.Runner.Plugins.Artifact
             Task uploadMonitor = UploadReportingAsync(context, files.Count(), _uploadCancellationTokenSource.Token);
 
             // Start parallel upload tasks.
-            List<Task<UploadResult>> parallelUploadingTasks = new List<Task<UploadResult>>();
+            List<Task<UploadResult>> parallelUploadingTasks = new();
             for (int uploader = 0; uploader < concurrentUploads; uploader++)
             {
                 parallelUploadingTasks.Add(UploadAsync(context, uploader, _uploadCancellationTokenSource.Token));
@@ -381,8 +381,8 @@ namespace GitHub.Runner.Plugins.Artifact
 
         private async Task<DownloadResult> DownloadAsync(RunnerActionPluginExecutionContext context, int downloaderId, CancellationToken token)
         {
-            List<DownloadInfo> failedFiles = new List<DownloadInfo>();
-            Stopwatch downloadTimer = new Stopwatch();
+            List<DownloadInfo> failedFiles = new();
+            Stopwatch downloadTimer = new();
             while (_fileDownloadQueue.TryDequeue(out DownloadInfo fileToDownload))
             {
                 token.ThrowIfCancellationRequested();
@@ -396,7 +396,7 @@ namespace GitHub.Runner.Plugins.Artifact
                         {
                             context.Debug($"Start downloading file: '{fileToDownload.ItemPath}' (Downloader {downloaderId})");
                             downloadTimer.Restart();
-                            using (FileStream fs = new FileStream(fileToDownload.LocalPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: _defaultFileStreamBufferSize, useAsync: true))
+                            using (FileStream fs = new(fileToDownload.LocalPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: _defaultFileStreamBufferSize, useAsync: true))
                             using (var downloadStream = await _fileContainerHttpClient.DownloadFileAsync(_containerId, fileToDownload.ItemPath, token, _projectId))
                             {
                                 await downloadStream.CopyToAsync(fs, _defaultCopyBufferSize, token);
@@ -453,10 +453,10 @@ namespace GitHub.Runner.Plugins.Artifact
 
         private async Task<UploadResult> UploadAsync(RunnerActionPluginExecutionContext context, int uploaderId, CancellationToken token)
         {
-            List<string> failedFiles = new List<string>();
+            List<string> failedFiles = new();
             long uploadedSize = 0;
             string fileToUpload;
-            Stopwatch uploadTimer = new Stopwatch();
+            Stopwatch uploadTimer = new();
             while (_fileUploadQueue.TryDequeue(out fileToUpload))
             {
                 token.ThrowIfCancellationRequested();

src/Runner.Plugins/Artifact/PublishArtifact.cs

@@ -68,7 +68,7 @@ namespace GitHub.Runner.Plugins.Artifact
 
             context.Output($"Uploading artifact '{artifactName}' from '{fullPath}' for run #{buildId}");
 
-            FileContainerServer fileContainerHelper = new FileContainerServer(context.VssConnection, projectId: Guid.Empty, containerId, artifactName);
+            FileContainerServer fileContainerHelper = new(context.VssConnection, projectId: Guid.Empty, containerId, artifactName);
             var propertiesDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
             long size = 0;
@@ -87,7 +87,7 @@ namespace GitHub.Runner.Plugins.Artifact
                 // Definition ID is a dummy value only used by HTTP client routing purposes
                 int definitionId = 1;
 
-                PipelinesServer pipelinesHelper = new PipelinesServer(context.VssConnection);
+                PipelinesServer pipelinesHelper = new(context.VssConnection);
 
                 var artifact = await pipelinesHelper.AssociateActionsStorageArtifactAsync(
                     definitionId,

src/Runner.Plugins/Repository/GitCliManager.cs

@@ -18,7 +18,7 @@ namespace GitHub.Runner.Plugins.Repository
 #else
         private static readonly Encoding s_encoding = null;
 #endif
-        private readonly Dictionary<string, string> gitEnv = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        private readonly Dictionary<string, string> gitEnv = new(StringComparer.OrdinalIgnoreCase)
         {
             { "GIT_TERMINAL_PROMPT", "0" },
         };
@@ -92,11 +92,11 @@ namespace GitHub.Runner.Plugins.Repository
             }
 
             // required 2.0, all git operation commandline args need min git version 2.0
-            Version minRequiredGitVersion = new Version(2, 0);
+            Version minRequiredGitVersion = new(2, 0);
             EnsureGitVersion(minRequiredGitVersion, throwOnNotMatch: true);
 
             // suggest user upgrade to 2.9 for better git experience
-            Version recommendGitVersion = new Version(2, 9);
+            Version recommendGitVersion = new(2, 9);
             if (!EnsureGitVersion(recommendGitVersion, throwOnNotMatch: false))
             {
                 context.Output($"To get a better Git experience, upgrade your Git to at least version '{recommendGitVersion}'. Your current Git version is '{gitVersion}'.");
@@ -430,7 +430,7 @@ namespace GitHub.Runner.Plugins.Repository
             context.Debug($"Inspect remote.origin.url for repository under {repositoryPath}");
             Uri fetchUrl = null;
 
-            List<string> outputStrings = new List<string>();
+            List<string> outputStrings = new();
             int exitCode = await ExecuteGitCommandAsync(context, repositoryPath, "config", "--get remote.origin.url", outputStrings);
 
             if (exitCode != 0)
@@ -477,7 +477,7 @@ namespace GitHub.Runner.Plugins.Repository
             context.Debug($"Checking git config {configKey} exist or not");
 
             // ignore any outputs by redirect them into a string list, since the output might contains secrets.
-            List<string> outputStrings = new List<string>();
+            List<string> outputStrings = new();
             int exitcode = await ExecuteGitCommandAsync(context, repositoryPath, "config", StringUtil.Format($"--get-all {configKey}"), outputStrings);
 
             return exitcode == 0;
@@ -539,7 +539,7 @@ namespace GitHub.Runner.Plugins.Repository
             string runnerWorkspace = context.GetRunnerContext("workspace");
             ArgUtil.Directory(runnerWorkspace, "runnerWorkspace");
             Version version = null;
-            List<string> outputStrings = new List<string>();
+            List<string> outputStrings = new();
             int exitCode = await ExecuteGitCommandAsync(context, runnerWorkspace, "version", null, outputStrings);
             context.Output($"{string.Join(Environment.NewLine, outputStrings)}");
             if (exitCode == 0)
@@ -550,7 +550,7 @@ namespace GitHub.Runner.Plugins.Repository
                 {
                     string verString = outputStrings.First();
                     // we interested about major.minor.patch version
-                    Regex verRegex = new Regex("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
+                    Regex verRegex = new("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
                     var matchResult = verRegex.Match(verString);
                     if (matchResult.Success && !string.IsNullOrEmpty(matchResult.Value))
                     {
@@ -572,7 +572,7 @@ namespace GitHub.Runner.Plugins.Repository
             string runnerWorkspace = context.GetRunnerContext("workspace");
             ArgUtil.Directory(runnerWorkspace, "runnerWorkspace");
             Version version = null;
-            List<string> outputStrings = new List<string>();
+            List<string> outputStrings = new();
             int exitCode = await ExecuteGitCommandAsync(context, runnerWorkspace, "lfs version", null, outputStrings);
             context.Output($"{string.Join(Environment.NewLine, outputStrings)}");
             if (exitCode == 0)
@@ -583,7 +583,7 @@ namespace GitHub.Runner.Plugins.Repository
                 {
                     string verString = outputStrings.First();
                     // we interested about major.minor.patch version
-                    Regex verRegex = new Regex("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
+                    Regex verRegex = new("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
                     var matchResult = verRegex.Match(verString);
                     if (matchResult.Success && !string.IsNullOrEmpty(matchResult.Value))
                     {

src/Runner.Plugins/Repository/v1.0/GitSourceProvider.cs

@@ -21,7 +21,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
         private const string _remotePullRefsPrefix = "refs/remotes/pull/";
 
         // min git version that support add extra auth header.
-        private Version _minGitVersionSupportAuthHeader = new Version(2, 9);
+        private Version _minGitVersionSupportAuthHeader = new(2, 9);
 
 #if OS_WINDOWS
         // min git version that support override sslBackend setting.
@@ -29,7 +29,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
 #endif
 
         // min git-lfs version that support add extra auth header.
-        private Version _minGitLfsVersionSupportAuthHeader = new Version(2, 1);
+        private Version _minGitLfsVersionSupportAuthHeader = new(2, 1);
 
         private void RequirementCheck(RunnerActionPluginExecutionContext executionContext, GitCliManager gitCommandManager, bool checkGitLfs)
         {
@@ -83,7 +83,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
             var githubUrl = executionContext.GetGitHubContext("server_url");
             var githubUri = new Uri(!string.IsNullOrEmpty(githubUrl) ? githubUrl : "https://github.com");
             var portInfo = githubUri.IsDefaultPort ? string.Empty : $":{githubUri.Port}";
-            Uri repositoryUrl = new Uri($"{githubUri.Scheme}://{githubUri.Host}{portInfo}/{repoFullName}");
+            Uri repositoryUrl = new($"{githubUri.Scheme}://{githubUri.Host}{portInfo}/{repoFullName}");
             if (!repositoryUrl.IsAbsoluteUri)
             {
                 throw new InvalidOperationException("Repository url need to be an absolute uri.");
@@ -121,7 +121,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
             executionContext.Debug($"gitLfsSupport={gitLfsSupport}");
 
             // Initialize git command manager with additional environment variables.
-            Dictionary<string, string> gitEnv = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            Dictionary<string, string> gitEnv = new(StringComparer.OrdinalIgnoreCase);
 
             // Disable prompting for git credential manager
             gitEnv["GCM_INTERACTIVE"] = "Never";
@@ -141,7 +141,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
                 gitEnv[formattedKey] = variable.Value?.Value ?? string.Empty;
             }
 
-            GitCliManager gitCommandManager = new GitCliManager(gitEnv);
+            GitCliManager gitCommandManager = new(gitEnv);
             await gitCommandManager.LoadGitExecutionInfo(executionContext);
 
             // Make sure the build machine met all requirements for the git repository
@@ -293,8 +293,8 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
                 await RemoveGitConfig(executionContext, gitCommandManager, targetPath, $"http.{repositoryUrl.AbsoluteUri}.extraheader", string.Empty);
             }
 
-            List<string> additionalFetchArgs = new List<string>();
-            List<string> additionalLfsFetchArgs = new List<string>();
+            List<string> additionalFetchArgs = new();
+            List<string> additionalLfsFetchArgs = new();
 
             // add accessToken as basic auth header to handle auth challenge. 
             if (!string.IsNullOrEmpty(accessToken))
@@ -320,7 +320,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
                 }
             }
 
-            List<string> additionalFetchSpecs = new List<string>();
+            List<string> additionalFetchSpecs = new();
             additionalFetchSpecs.Add("+refs/heads/*:refs/remotes/origin/*");
 
             if (IsPullRequest(sourceBranch))
@@ -395,7 +395,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
                     throw new InvalidOperationException($"Git submodule sync failed with exit code: {exitCode_submoduleSync}");
                 }
 
-                List<string> additionalSubmoduleUpdateArgs = new List<string>();
+                List<string> additionalSubmoduleUpdateArgs = new();
 
                 if (!string.IsNullOrEmpty(accessToken))
                 {

src/Runner.Plugins/Repository/v1.0/RepositoryPlugin.cs

@@ -12,7 +12,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_0
 {
     public class CheckoutTask : IRunnerActionPlugin
     {
-        private readonly Regex _validSha1 = new Regex(@"\b[0-9a-f]{40}\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled, TimeSpan.FromSeconds(2));
+        private readonly Regex _validSha1 = new(@"\b[0-9a-f]{40}\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled, TimeSpan.FromSeconds(2));
 
         public async Task RunAsync(RunnerActionPluginExecutionContext executionContext, CancellationToken token)
         {

src/Runner.Plugins/Repository/v1.1/GitSourceProvider.cs

@@ -22,7 +22,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
         private const string _tagRefsPrefix = "refs/tags/";
 
         // min git version that support add extra auth header.
-        private Version _minGitVersionSupportAuthHeader = new Version(2, 9);
+        private Version _minGitVersionSupportAuthHeader = new(2, 9);
 
 #if OS_WINDOWS
         // min git version that support override sslBackend setting.
@@ -30,7 +30,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
 #endif
 
         // min git-lfs version that support add extra auth header.
-        private Version _minGitLfsVersionSupportAuthHeader = new Version(2, 1);
+        private Version _minGitLfsVersionSupportAuthHeader = new(2, 1);
 
         public static string ProblemMatcher => @"    
 {
@@ -62,9 +62,9 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
         {
             // Validate args.
             ArgUtil.NotNull(executionContext, nameof(executionContext));
-            Dictionary<string, string> configModifications = new Dictionary<string, string>();
+            Dictionary<string, string> configModifications = new();
             executionContext.Output($"Syncing repository: {repoFullName}");
-            Uri repositoryUrl = new Uri($"https://github.com/{repoFullName}");
+            Uri repositoryUrl = new($"https://github.com/{repoFullName}");
             if (!repositoryUrl.IsAbsoluteUri)
             {
                 throw new InvalidOperationException("Repository url need to be an absolute uri.");
@@ -102,7 +102,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
             executionContext.Debug($"gitLfsSupport={gitLfsSupport}");
 
             // Initialize git command manager with additional environment variables.
-            Dictionary<string, string> gitEnv = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            Dictionary<string, string> gitEnv = new(StringComparer.OrdinalIgnoreCase);
 
             // Disable git prompt
             gitEnv["GIT_TERMINAL_PROMPT"] = "0";
@@ -125,7 +125,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
                 gitEnv[formattedKey] = variable.Value?.Value ?? string.Empty;
             }
 
-            GitCliManager gitCommandManager = new GitCliManager(gitEnv);
+            GitCliManager gitCommandManager = new(gitEnv);
             await gitCommandManager.LoadGitExecutionInfo(executionContext);
 
             // Make sure the build machine met all requirements for the git repository
@@ -277,8 +277,8 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
                 await RemoveGitConfig(executionContext, gitCommandManager, targetPath, $"http.{repositoryUrl.AbsoluteUri}.extraheader", string.Empty);
             }
 
-            List<string> additionalFetchArgs = new List<string>();
-            List<string> additionalLfsFetchArgs = new List<string>();
+            List<string> additionalFetchArgs = new();
+            List<string> additionalLfsFetchArgs = new();
 
             // Add http.https://github.com.extraheader=... to gitconfig
             // accessToken as basic auth header to handle any auth challenge from github.com 
@@ -303,7 +303,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
                 }
             }
 
-            List<string> additionalFetchSpecs = new List<string>();
+            List<string> additionalFetchSpecs = new();
             additionalFetchSpecs.Add("+refs/heads/*:refs/remotes/origin/*");
 
             if (IsPullRequest(sourceBranch))
@@ -378,7 +378,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
                     throw new InvalidOperationException($"Git submodule sync failed with exit code: {exitCode_submoduleSync}");
                 }
 
-                List<string> additionalSubmoduleUpdateArgs = new List<string>();
+                List<string> additionalSubmoduleUpdateArgs = new();
 
                 int exitCode_submoduleUpdate = await gitCommandManager.GitSubmoduleUpdate(executionContext, targetPath, fetchDepth, string.Join(" ", additionalSubmoduleUpdateArgs), checkoutNestedSubmodules, cancellationToken);
                 if (exitCode_submoduleUpdate != 0)
@@ -404,7 +404,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
             executionContext.Output($"Cleanup cached git credential from {repositoryPath}.");
 
             // Initialize git command manager
-            GitCliManager gitCommandManager = new GitCliManager();
+            GitCliManager gitCommandManager = new();
             await gitCommandManager.LoadGitExecutionInfo(executionContext);
 
             executionContext.Debug("Remove any extraheader setting from git config.");
@@ -499,7 +499,7 @@ namespace GitHub.Runner.Plugins.Repository.v1_1
                     string gitConfig = Path.Combine(targetPath, ".git/config");
                     if (File.Exists(gitConfig))
                     {
-                        List<string> safeGitConfig = new List<string>();
+                        List<string> safeGitConfig = new();
                         var gitConfigContents = File.ReadAllLines(gitConfig);
                         foreach (var line in gitConfigContents)
                         {

src/Runner.Sdk/ActionPlugin.cs

@@ -23,7 +23,7 @@ namespace GitHub.Runner.Sdk
         private readonly string DebugEnvironmentalVariable = "ACTIONS_STEP_DEBUG";
         private VssConnection _connection;
         private RunnerWebProxy _webProxy;
-        private readonly object _stdoutLock = new object();
+        private readonly object _stdoutLock = new();
         private readonly ITraceWriter _trace; // for unit tests
 
         public RunnerActionPluginExecutionContext()
@@ -220,7 +220,7 @@ namespace GitHub.Runner.Sdk
             return input;
         }
 
-        private Dictionary<string, string> _commandEscapeMappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        private Dictionary<string, string> _commandEscapeMappings = new(StringComparer.OrdinalIgnoreCase)
         {
             {
                 ";", "%3B"

src/Runner.Sdk/ProcessInvoker.cs

@@ -24,18 +24,18 @@ namespace GitHub.Runner.Sdk
         private Stopwatch _stopWatch;
         private int _asyncStreamReaderCount = 0;
         private bool _waitingOnStreams = false;
-        private readonly AsyncManualResetEvent _outputProcessEvent = new AsyncManualResetEvent();
-        private readonly TaskCompletionSource<bool> _processExitedCompletionSource = new TaskCompletionSource<bool>();
-        private readonly CancellationTokenSource _processStandardInWriteCancellationTokenSource = new CancellationTokenSource();
-        private readonly ConcurrentQueue<string> _errorData = new ConcurrentQueue<string>();
-        private readonly ConcurrentQueue<string> _outputData = new ConcurrentQueue<string>();
+        private readonly AsyncManualResetEvent _outputProcessEvent = new();
+        private readonly TaskCompletionSource<bool> _processExitedCompletionSource = new();
+        private readonly CancellationTokenSource _processStandardInWriteCancellationTokenSource = new();
+        private readonly ConcurrentQueue<string> _errorData = new();
+        private readonly ConcurrentQueue<string> _outputData = new();
         private readonly TimeSpan _sigintTimeout = TimeSpan.FromMilliseconds(7500);
         private readonly TimeSpan _sigtermTimeout = TimeSpan.FromMilliseconds(2500);
         private ITraceWriter Trace { get; set; }
 
         private class AsyncManualResetEvent
         {
-            private volatile TaskCompletionSource<bool> m_tcs = new TaskCompletionSource<bool>();
+            private volatile TaskCompletionSource<bool> m_tcs = new();
 
             public Task WaitAsync() { return m_tcs.Task; }
 
@@ -264,7 +264,17 @@ namespace GitHub.Runner.Sdk
             {
                 foreach (KeyValuePair<string, string> kvp in environment)
                 {
+#if OS_WINDOWS
+                    string tempKey = String.IsNullOrWhiteSpace(kvp.Key) ? kvp.Key : kvp.Key.Split('\0')[0];
+                    string tempValue = String.IsNullOrWhiteSpace(kvp.Value) ? kvp.Value : kvp.Value.Split('\0')[0];
+                    if(!String.IsNullOrWhiteSpace(tempKey))
+                    {
+                         _proc.StartInfo.Environment[tempKey] = tempValue;
+                    }
+#else
                     _proc.StartInfo.Environment[kvp.Key] = kvp.Value;
+
+#endif
                 }
             }
 
@@ -387,8 +397,8 @@ namespace GitHub.Runner.Sdk
 
         private void ProcessOutput()
         {
-            List<string> errorData = new List<string>();
-            List<string> outputData = new List<string>();
+            List<string> errorData = new();
+            List<string> outputData = new();
 
             string errorLine;
             while (_errorData.TryDequeue(out errorLine))

src/Runner.Sdk/RunnerWebProxy.cs

@@ -23,9 +23,9 @@ namespace GitHub.Runner.Sdk
         private string _httpsProxyPassword;
         private string _noProxyString;
 
-        private readonly List<ByPassInfo> _noProxyList = new List<ByPassInfo>();
-        private readonly HashSet<string> _noProxyUnique = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        private readonly Regex _validIpRegex = new Regex("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", RegexOptions.Compiled);
+        private readonly List<ByPassInfo> _noProxyList = new();
+        private readonly HashSet<string> _noProxyUnique = new(StringComparer.OrdinalIgnoreCase);
+        private readonly Regex _validIpRegex = new("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", RegexOptions.Compiled);
 
         public string HttpProxyAddress => _httpProxyAddress;
         public string HttpProxyUsername => _httpProxyUsername;

src/Runner.Sdk/Util/IOUtil.cs

@@ -52,7 +52,7 @@ namespace GitHub.Runner.Sdk
             using (SHA256 sha256hash = SHA256.Create())
             {
                 byte[] data = sha256hash.ComputeHash(Encoding.UTF8.GetBytes(hashString));
-                StringBuilder sBuilder = new StringBuilder();
+                StringBuilder sBuilder = new();
                 for (int i = 0; i < data.Length; i++)
                 {
                     sBuilder.Append(data[i].ToString("x2"));
@@ -77,7 +77,7 @@ namespace GitHub.Runner.Sdk
         public static void DeleteDirectory(string path, bool contentsOnly, bool continueOnContentDeleteError, CancellationToken cancellationToken)
         {
             ArgUtil.NotNullOrEmpty(path, nameof(path));
-            DirectoryInfo directory = new DirectoryInfo(path);
+            DirectoryInfo directory = new(path);
             if (!directory.Exists)
             {
                 return;
@@ -363,12 +363,12 @@ namespace GitHub.Runner.Sdk
             Directory.CreateDirectory(target);
 
             // Get the file contents of the directory to copy.
-            DirectoryInfo sourceDir = new DirectoryInfo(source);
+            DirectoryInfo sourceDir = new(source);
             foreach (FileInfo sourceFile in sourceDir.GetFiles() ?? new FileInfo[0])
             {
                 // Check if the file already exists.
                 cancellationToken.ThrowIfCancellationRequested();
-                FileInfo targetFile = new FileInfo(Path.Combine(target, sourceFile.Name));
+                FileInfo targetFile = new(Path.Combine(target, sourceFile.Name));
                 if (!targetFile.Exists ||
                     sourceFile.Length != targetFile.Length ||
                     sourceFile.LastWriteTime != targetFile.LastWriteTime)

src/Runner.Sdk/Util/StringUtil.cs

@@ -9,7 +9,7 @@ namespace GitHub.Runner.Sdk
     public static class StringUtil
     {
         private static readonly object[] s_defaultFormatArgs = new object[] { null };
-        private static Lazy<JsonSerializerSettings> s_serializerSettings = new Lazy<JsonSerializerSettings>(() =>
+        private static Lazy<JsonSerializerSettings> s_serializerSettings = new(() =>
         {
             var settings = new VssJsonMediaTypeFormatter().SerializerSettings;
             settings.DateParseHandling = DateParseHandling.None;

src/Runner.Sdk/Util/UrlUtil.cs

@@ -21,7 +21,7 @@ namespace GitHub.Runner.Sdk
                 return baseUrl;
             }
 
-            UriBuilder credUri = new UriBuilder(baseUrl);
+            UriBuilder credUri = new(baseUrl);
 
             // ensure we have a username, uribuild will throw if username is empty but password is not.
             if (string.IsNullOrEmpty(username))

src/Runner.Sdk/Util/VssUtil.cs

@@ -9,6 +9,7 @@ using GitHub.Services.OAuth;
 using System.Net.Http.Headers;
 using System.Runtime.InteropServices;
 using System.Net;
+using Sdk.WebApi.WebApi.RawClient;
 
 namespace GitHub.Runner.Sdk
 {
@@ -34,7 +35,11 @@ namespace GitHub.Runner.Sdk
             }
         }
 
-        public static VssConnection CreateConnection(Uri serverUri, VssCredentials credentials, IEnumerable<DelegatingHandler> additionalDelegatingHandler = null, TimeSpan? timeout = null)
+        public static VssConnection CreateConnection(
+            Uri serverUri,
+            VssCredentials credentials,
+            IEnumerable<DelegatingHandler> additionalDelegatingHandler = null,
+            TimeSpan? timeout = null)
         {
             VssClientHttpRequestSettings settings = VssClientHttpRequestSettings.Default.Clone();
 
@@ -71,7 +76,47 @@ namespace GitHub.Runner.Sdk
             // settings are applied to an HttpRequestMessage.
             settings.AcceptLanguages.Remove(CultureInfo.InvariantCulture);
 
-            VssConnection connection = new VssConnection(serverUri, new VssHttpMessageHandler(credentials, settings), additionalDelegatingHandler);
+            VssConnection connection = new(serverUri, new VssHttpMessageHandler(credentials, settings), additionalDelegatingHandler);
+            return connection;
+        }
+
+        public static RawConnection CreateRawConnection(
+            Uri serverUri,
+            VssCredentials credentials,
+            IEnumerable<DelegatingHandler> additionalDelegatingHandler = null,
+            TimeSpan? timeout = null)
+        {
+            RawClientHttpRequestSettings settings = RawClientHttpRequestSettings.Default.Clone();
+
+            int maxRetryRequest;
+            if (!int.TryParse(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_HTTP_RETRY") ?? string.Empty, out maxRetryRequest))
+            {
+                maxRetryRequest = 3;
+            }
+
+            // make sure MaxRetryRequest in range [3, 10]
+            settings.MaxRetryRequest = Math.Min(Math.Max(maxRetryRequest, 3), 10);
+
+            if (!int.TryParse(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_HTTP_TIMEOUT") ?? string.Empty, out int httpRequestTimeoutSeconds))
+            {
+                settings.SendTimeout = timeout ?? TimeSpan.FromSeconds(100);
+            }
+            else
+            {
+                // prefer environment variable
+                settings.SendTimeout = TimeSpan.FromSeconds(Math.Min(Math.Max(httpRequestTimeoutSeconds, 100), 1200));
+            }
+
+            // Remove Invariant from the list of accepted languages.
+            //
+            // The constructor of VssHttpRequestSettings (base class of VssClientHttpRequestSettings) adds the current
+            // UI culture to the list of accepted languages. The UI culture will be Invariant on OSX/Linux when the
+            // LANG environment variable is not set when the program starts. If Invariant is in the list of accepted
+            // languages, then "System.ArgumentException: The value cannot be null or empty." will be thrown when the
+            // settings are applied to an HttpRequestMessage.
+            settings.AcceptLanguages.Remove(CultureInfo.InvariantCulture);
+
+            RawConnection connection = new(serverUri, new RawHttpMessageHandler(credentials.ToOAuthCredentials(), settings), additionalDelegatingHandler);
             return connection;
         }
 

src/Runner.Worker/ActionCommandManager.cs

@@ -21,9 +21,9 @@ namespace GitHub.Runner.Worker
     public sealed class ActionCommandManager : RunnerService, IActionCommandManager
     {
         private const string _stopCommand = "stop-commands";
-        private readonly Dictionary<string, IActionCommandExtension> _commandExtensions = new Dictionary<string, IActionCommandExtension>(StringComparer.OrdinalIgnoreCase);
-        private readonly HashSet<string> _registeredCommands = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        private readonly object _commandSerializeLock = new object();
+        private readonly Dictionary<string, IActionCommandExtension> _commandExtensions = new(StringComparer.OrdinalIgnoreCase);
+        private readonly HashSet<string> _registeredCommands = new(StringComparer.OrdinalIgnoreCase);
+        private readonly object _commandSerializeLock = new();
         private bool _stopProcessCommand = false;
         private string _stopToken = null;
 
@@ -618,7 +618,7 @@ namespace GitHub.Runner.Worker
                 context.Debug("Enhanced Annotations not enabled on the server. The 'title', 'end_line', and 'end_column' fields are unsupported.");
             }
 
-            Issue issue = new Issue()
+            Issue issue = new()
             {
                 Category = "General",
                 Type = this.Type,

src/Runner.Worker/ActionManager.cs

@@ -52,16 +52,16 @@ namespace GitHub.Runner.Worker
         private const int _defaultCopyBufferSize = 81920;
         private const string _dotcomApiUrl = "https://api.github.com";
 
-        private readonly Dictionary<Guid, ContainerInfo> _cachedActionContainers = new Dictionary<Guid, ContainerInfo>();
+        private readonly Dictionary<Guid, ContainerInfo> _cachedActionContainers = new();
         public Dictionary<Guid, ContainerInfo> CachedActionContainers => _cachedActionContainers;
 
-        private readonly Dictionary<Guid, List<Pipelines.ActionStep>> _cachedEmbeddedPreSteps = new Dictionary<Guid, List<Pipelines.ActionStep>>();
+        private readonly Dictionary<Guid, List<Pipelines.ActionStep>> _cachedEmbeddedPreSteps = new();
         public Dictionary<Guid, List<Pipelines.ActionStep>> CachedEmbeddedPreSteps => _cachedEmbeddedPreSteps;
 
-        private readonly Dictionary<Guid, List<Guid>> _cachedEmbeddedStepIds = new Dictionary<Guid, List<Guid>>();
+        private readonly Dictionary<Guid, List<Guid>> _cachedEmbeddedStepIds = new();
         public Dictionary<Guid, List<Guid>> CachedEmbeddedStepIds => _cachedEmbeddedStepIds;
 
-        private readonly Dictionary<Guid, Stack<Pipelines.ActionStep>> _cachedEmbeddedPostSteps = new Dictionary<Guid, Stack<Pipelines.ActionStep>>();
+        private readonly Dictionary<Guid, Stack<Pipelines.ActionStep>> _cachedEmbeddedPostSteps = new();
         public Dictionary<Guid, Stack<Pipelines.ActionStep>> CachedEmbeddedPostSteps => _cachedEmbeddedPostSteps;
 
         public async Task<PrepareResult> PrepareActionsAsync(IExecutionContext executionContext, IEnumerable<Pipelines.JobStep> steps, Guid rootStepId = default(Guid))
@@ -791,7 +791,7 @@ namespace GitHub.Runner.Worker
                         try
                         {
                             //open zip stream in async mode
-                            using (FileStream fs = new FileStream(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: _defaultFileStreamBufferSize, useAsync: true))
+                            using (FileStream fs = new(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: _defaultFileStreamBufferSize, useAsync: true))
                             using (var httpClientHandler = HostContext.CreateHttpClientHandler())
                             using (var httpClient = new HttpClient(httpClientHandler))
                             {

src/Runner.Worker/ActionManifestManager.cs

@@ -53,7 +53,7 @@ namespace GitHub.Runner.Worker
         public ActionDefinitionData Load(IExecutionContext executionContext, string manifestFile)
         {
             var templateContext = CreateTemplateContext(executionContext);
-            ActionDefinitionData actionDefinition = new ActionDefinitionData();
+            ActionDefinitionData actionDefinition = new();
 
             // Clean up file name real quick
             // Instead of using Regex which can be computationally expensive, 

src/Runner.Worker/ConditionTraceWriter.cs

@@ -10,7 +10,7 @@ namespace GitHub.Runner.Worker
     {
         private readonly IExecutionContext _executionContext;
         private readonly Tracing _trace;
-        private readonly StringBuilder _traceBuilder = new StringBuilder();
+        private readonly StringBuilder _traceBuilder = new();
 
         public string Trace => _traceBuilder.ToString();
 

src/Runner.Worker/Container/ContainerInfo.cs

@@ -15,7 +15,7 @@ namespace GitHub.Runner.Worker.Container
         private IDictionary<string, string> _userPortMappings;
         private List<PortMapping> _portMappings;
         private IDictionary<string, string> _environmentVariables;
-        private List<PathMapping> _pathMappings = new List<PathMapping>();
+        private List<PathMapping> _pathMappings = new();
 
         public ContainerInfo()
         {

src/Runner.Worker/Container/DockerCommandManager.cs

@@ -60,7 +60,7 @@ namespace GitHub.Runner.Worker.Container
             context.Output($"Docker client API version: {clientVersionStr}");
 
             // we interested about major.minor.patch version
-            Regex verRegex = new Regex("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
+            Regex verRegex = new("\\d+\\.\\d+(\\.\\d+)?", RegexOptions.IgnoreCase);
 
             Version serverVersion = null;
             var serverVersionMatchResult = verRegex.Match(serverVersionStr);
@@ -309,7 +309,7 @@ namespace GitHub.Runner.Worker.Container
             string arg = $"exec {options} {containerId} {command}".Trim();
             context.Command($"{DockerPath} {arg}");
 
-            object outputLock = new object();
+            object outputLock = new();
             var processInvoker = HostContext.CreateService<IProcessInvoker>();
             processInvoker.OutputDataReceived += delegate (object sender, ProcessDataReceivedEventArgs message)
             {
@@ -447,7 +447,7 @@ namespace GitHub.Runner.Worker.Container
             string arg = $"{command} {options}".Trim();
             context.Command($"{DockerPath} {arg}");
 
-            List<string> output = new List<string>();
+            List<string> output = new();
             var processInvoker = HostContext.CreateService<IProcessInvoker>();
             processInvoker.OutputDataReceived += delegate (object sender, ProcessDataReceivedEventArgs message)
             {

src/Runner.Worker/Container/DockerUtil.cs

@@ -6,8 +6,8 @@ namespace GitHub.Runner.Worker.Container
 {
     public class DockerUtil
     {
-        private static readonly Regex QuoteEscape = new Regex(@"(\\*)" + "\"", RegexOptions.Compiled);
-        private static readonly Regex EndOfStringEscape = new Regex(@"(\\+)$", RegexOptions.Compiled);
+        private static readonly Regex QuoteEscape = new(@"(\\*)" + "\"", RegexOptions.Compiled);
+        private static readonly Regex EndOfStringEscape = new(@"(\\+)$", RegexOptions.Compiled);
 
         public static List<PortMapping> ParseDockerPort(IList<string> portMappingLines)
         {
@@ -19,7 +19,7 @@ namespace GitHub.Runner.Worker.Container
             //"TARGET_PORT/PROTO -> HOST:HOST_PORT"
             string pattern = $"^(?<{targetPort}>\\d+)/(?<{proto}>\\w+) -> (?<{host}>.+):(?<{hostPort}>\\d+)$";
 
-            List<PortMapping> portMappings = new List<PortMapping>();
+            List<PortMapping> portMappings = new();
             foreach (var line in portMappingLines)
             {
                 Match m = Regex.Match(line, pattern, RegexOptions.None, TimeSpan.FromSeconds(1));

src/Runner.Worker/ContainerOperationProvider.cs

@@ -33,9 +33,15 @@ namespace GitHub.Runner.Worker
         public override void Initialize(IHostContext hostContext)
         {
             base.Initialize(hostContext);
+            if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable(Constants.Hooks.ContainerHooksPath)))
+            {
                 _dockerManager = HostContext.GetService<IDockerCommandManager>();
+            }
+            else
+            {
                 _containerHookManager = HostContext.GetService<IContainerHookManager>();
             }
+        }
 
         public async Task StartContainersAsync(IExecutionContext executionContext, object data)
         {
@@ -108,9 +114,9 @@ namespace GitHub.Runner.Worker
             var unhealthyContainers = new List<ContainerInfo>();
             foreach (var container in containers.Where(c => !c.IsJobContainer))
             {
-                var healthcheck = await ContainerHealthcheck(executionContext, container);
+                var healthy_container = await ContainerHealthcheck(executionContext, container);
 
-                if (!string.Equals(healthcheck, "healthy", StringComparison.OrdinalIgnoreCase))
+                if (!healthy_container)
                 {
                     unhealthyContainers.Add(container);
                 }
@@ -354,8 +360,8 @@ namespace GitHub.Runner.Worker
         {
             context.Command($"{command} {arg}");
 
-            List<string> outputs = new List<string>();
-            object outputLock = new object();
+            List<string> outputs = new();
+            object outputLock = new();
             var processInvoker = HostContext.CreateService<IProcessInvoker>();
             processInvoker.OutputDataReceived += delegate (object sender, ProcessDataReceivedEventArgs message)
             {
@@ -423,14 +429,14 @@ namespace GitHub.Runner.Worker
             }
         }
 
-        private async Task<string> ContainerHealthcheck(IExecutionContext executionContext, ContainerInfo container)
+        private async Task<bool> ContainerHealthcheck(IExecutionContext executionContext, ContainerInfo container)
         {
             string healthCheck = "--format=\"{{if .Config.Healthcheck}}{{print .State.Health.Status}}{{end}}\"";
             string serviceHealth = (await _dockerManager.DockerInspect(context: executionContext, dockerObject: container.ContainerId, options: healthCheck)).FirstOrDefault();
             if (string.IsNullOrEmpty(serviceHealth))
             {
                 // Container has no HEALTHCHECK
-                return String.Empty;
+                return true;
             }
             var retryCount = 0;
             while (string.Equals(serviceHealth, "starting", StringComparison.OrdinalIgnoreCase))
@@ -441,7 +447,7 @@ namespace GitHub.Runner.Worker
                 serviceHealth = (await _dockerManager.DockerInspect(context: executionContext, dockerObject: container.ContainerId, options: healthCheck)).FirstOrDefault();
                 retryCount++;
             }
-            return serviceHealth;
+            return string.Equals(serviceHealth, "healthy", StringComparison.OrdinalIgnoreCase);
         }
 
         private async Task<string> ContainerRegistryLogin(IExecutionContext executionContext, ContainerInfo container)
@@ -562,7 +568,7 @@ namespace GitHub.Runner.Worker
 #if OS_WINDOWS
             Version requiredDockerEngineAPIVersion = new Version(1, 30);  // Docker-EE version 17.6
 #else
-            Version requiredDockerEngineAPIVersion = new Version(1, 35); // Docker-CE version 17.12
+            Version requiredDockerEngineAPIVersion = new(1, 35); // Docker-CE version 17.12
 #endif
 
             if (dockerVersion.ServerVersion < requiredDockerEngineAPIVersion)

src/Runner.Worker/ExecutionContext.cs

@@ -80,6 +80,7 @@ namespace GitHub.Runner.Worker
         // logging
         long Write(string tag, string message);
         void QueueAttachFile(string type, string name, string filePath);
+        void QueueSummaryFile(string name, string filePath,  Guid stepRecordId);
 
         // timeline record update methods
         void Start(string currentOperation = null);
@@ -122,10 +123,10 @@ namespace GitHub.Runner.Worker
         private const int _maxIssueCountInTelemetry = 3; // Only send the first 3 issues to telemetry
         private const int _maxIssueMessageLengthInTelemetry = 256; // Only send the first 256 characters of issue message to telemetry
 
-        private readonly TimelineRecord _record = new TimelineRecord();
-        private readonly Dictionary<Guid, TimelineRecord> _detailRecords = new Dictionary<Guid, TimelineRecord>();
-        private readonly object _loggerLock = new object();
-        private readonly object _matchersLock = new object();
+        private readonly TimelineRecord _record = new();
+        private readonly Dictionary<Guid, TimelineRecord> _detailRecords = new();
+        private readonly object _loggerLock = new();
+        private readonly object _matchersLock = new();
 
         private event OnMatcherChanged _onMatcherChanged;
 
@@ -140,7 +141,7 @@ namespace GitHub.Runner.Worker
         private bool _expandedForPostJob = false;
         private int _childTimelineRecordOrder = 0;
         private CancellationTokenSource _cancellationTokenSource;
-        private TaskCompletionSource<int> _forceCompleted = new TaskCompletionSource<int>();
+        private TaskCompletionSource<int> _forceCompleted = new();
         private bool _throttlingReported = false;
 
         // only job level ExecutionContext will track throttling delay.
@@ -686,8 +687,11 @@ namespace GitHub.Runner.Worker
             // Endpoints
             Global.Endpoints = message.Resources.Endpoints;
 
-            // Variables
-            Global.Variables = new Variables(HostContext, message.Variables);
+            // Ser debug using vars context if debug variables are not already present.
+            var variables = message.Variables;
+            SetDebugUsingVars(variables, message.ContextData);
+
+            Global.Variables = new Variables(HostContext, variables);
 
             if (Global.Variables.GetBoolean("DistributedTask.ForceInternalNodeVersionOnRunnerTo12") ?? false)
             {
@@ -843,6 +847,19 @@ namespace GitHub.Runner.Worker
             _jobServerQueue.QueueFileUpload(_mainTimelineId, _record.Id, type, name, filePath, deleteSource: false);
         }
 
+        public void QueueSummaryFile(string name, string filePath, Guid stepRecordId)
+        {
+            ArgUtil.NotNullOrEmpty(name, nameof(name));
+            ArgUtil.NotNullOrEmpty(filePath, nameof(filePath));
+
+            if (!File.Exists(filePath))
+            {
+                throw new FileNotFoundException($"Can't upload (name:{name}) file: {filePath}. File does not exist.");
+            }
+
+            _jobServerQueue.QueueSummaryUpload(stepRecordId, name, filePath, deleteSource: false);
+        }
+
         // Add OnMatcherChanged
         public void Add(OnMatcherChanged handler)
         {
@@ -1077,6 +1094,31 @@ namespace GitHub.Runner.Worker
             return CreateChild(newGuid, displayName, newGuid.ToString("N"), null, null, ActionRunStage.Post, intraActionState, _childTimelineRecordOrder - Root.PostJobSteps.Count, siblingScopeName: siblingScopeName);
         }
 
+        // Sets debug using vars context in case debug variables are not present.
+        private static void SetDebugUsingVars(IDictionary<string, VariableValue> variables, IDictionary<string, PipelineContextData> contextData)
+        {
+            if (contextData != null &&
+                contextData.TryGetValue(PipelineTemplateConstants.Vars, out var varsPipelineContextData) &&
+                varsPipelineContextData != null &&
+                varsPipelineContextData is DictionaryContextData varsContextData)
+            {
+                // Set debug variables only when StepDebug/RunnerDebug variables are not present.
+                if (!variables.ContainsKey(Constants.Variables.Actions.StepDebug) &&
+                    varsContextData.TryGetValue(Constants.Variables.Actions.StepDebug, out var stepDebugValue) &&
+                    stepDebugValue is StringContextData)
+                {
+                    variables[Constants.Variables.Actions.StepDebug] = stepDebugValue.ToString();
+                }
+
+                if (!variables.ContainsKey(Constants.Variables.Actions.RunnerDebug) &&
+                    varsContextData.TryGetValue(Constants.Variables.Actions.RunnerDebug, out var runDebugValue) &&
+                    runDebugValue is StringContextData)
+                {
+                    variables[Constants.Variables.Actions.RunnerDebug] = runDebugValue.ToString();
+                }
+            }
+        }
+
         public void ApplyContinueOnError(TemplateToken continueOnErrorToken)
         {
             if (Result != TaskResult.Failed)

src/Runner.Worker/Expressions/HashFilesFunction.cs

@@ -32,7 +32,7 @@ namespace GitHub.Runner.Worker.Expressions
 
             string githubWorkspace = workspaceData.Value;
             bool followSymlink = false;
-            List<string> patterns = new List<string>();
+            List<string> patterns = new();
             var firstParameter = true;
             foreach (var parameter in Parameters)
             {

src/Runner.Worker/FileCommandManager.cs

@@ -211,6 +211,16 @@ namespace GitHub.Runner.Worker
                 Trace.Info($"Queueing file ({filePath}) for attachment upload ({attachmentName})");
                 // Attachments must be added to the parent context (job), not the current context (step)
                 context.Root.QueueAttachFile(ChecksAttachmentType.StepSummary, attachmentName, scrubbedFilePath);
+
+                // Dual upload the same files to Results Service
+                context.Global.Variables.TryGetValue("system.github.results_endpoint", out string resultsReceiverEndpoint);
+                if (resultsReceiverEndpoint != null)
+                {
+                    Trace.Info($"Queueing results file ({filePath}) for attachment upload ({attachmentName})");
+                    var stepId = context.Id;
+                    // Attachments must be added to the parent context (job), not the current context (step)
+                    context.Root.QueueSummaryFile(attachmentName, scrubbedFilePath, stepId);
+                }
             }
             catch (Exception e)
             {

src/Runner.Worker/GitHubContext.cs

@@ -6,13 +6,14 @@ namespace GitHub.Runner.Worker
 {
     public sealed class GitHubContext : DictionaryContextData, IEnvironmentContextData
     {
-        private readonly HashSet<string> _contextEnvAllowlist = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        private readonly HashSet<string> _contextEnvAllowlist = new(StringComparer.OrdinalIgnoreCase)
         {
             "action_path",
             "action_ref",
             "action_repository",
             "action",
             "actor",
+            "actor_id",
             "api_url",
             "base_ref",
             "env",
@@ -27,8 +28,10 @@ namespace GitHub.Runner.Worker
             "ref_protected",
             "ref_type",
             "ref",
-            "repository_owner",
             "repository",
+            "repository_id",
+            "repository_owner",
+            "repository_owner_id",
             "retention_days",
             "run_attempt",
             "run_id",
@@ -39,7 +42,9 @@ namespace GitHub.Runner.Worker
             "step_summary",
             "triggering_actor",
             "workflow",
-            "workspace",
+            "workflow_ref",
+            "workflow_sha",
+            "workspace"
         };
 
         public IEnumerable<KeyValuePair<string, string>> GetRuntimeEnvironmentVariables()

src/Runner.Worker/Handlers/CompositeActionHandler.cs

@@ -239,7 +239,7 @@ namespace GitHub.Runner.Worker.Handlers
 
                 // Set action_status to the success of the current composite action
                 var actionResult = ExecutionContext.Result?.ToActionResult() ?? ActionResult.Success;
-                step.ExecutionContext.SetGitHubContext("action_status", actionResult.ToString());
+                step.ExecutionContext.SetGitHubContext("action_status", actionResult.ToString().ToLowerInvariant());
 
                 // Initialize env context
                 Trace.Info("Initialize Env context for embedded step");

src/Runner.Worker/Handlers/ContainerActionHandler.cs

@@ -38,8 +38,17 @@ namespace GitHub.Runner.Worker.Handlers
             // Update the env dictionary.
             AddInputsToEnvironment();
 
-            var dockerManager = HostContext.GetService<IDockerCommandManager>();
-            var containerHookManager = HostContext.GetService<IContainerHookManager>();
+            IDockerCommandManager dockerManager = null;
+            IContainerHookManager containerHookManager = null;
+            if (FeatureManager.IsContainerHooksEnabled(ExecutionContext.Global.Variables))
+            {
+                containerHookManager = HostContext.GetService<IContainerHookManager>();
+            }
+            else
+            {
+                dockerManager = HostContext.GetService<IDockerCommandManager>();
+            }
+
             string dockerFile = null;
 
             // container image haven't built/pull

src/Runner.Worker/Handlers/NodeScriptActionHandler.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -7,8 +8,8 @@ using GitHub.DistributedTask.Pipelines;
 using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
-using GitHub.Runner.Sdk;
 using GitHub.Runner.Common.Util;
+using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker.Container;
 using GitHub.Runner.Worker.Container.ContainerHooks;
 
@@ -137,13 +138,25 @@ namespace GitHub.Runner.Worker.Handlers
 
             if (Data.NodeVersion == "node12" && (ExecutionContext.Global.Variables.GetBoolean(Constants.Runner.Features.Node12Warning) ?? false))
             {
-                if (!ExecutionContext.JobContext.ContainsKey("Node12ActionsWarnings"))
-                {
-                    ExecutionContext.JobContext["Node12ActionsWarnings"] = new ArrayContextData();
-                }
                 var repoAction = Action as RepositoryPathReference;
-                var actionDisplayName = new StringContextData(repoAction.Name ?? repoAction.Path); // local actions don't have a 'Name'
-                ExecutionContext.JobContext["Node12ActionsWarnings"].AssertArray("Node12ActionsWarnings").Add(actionDisplayName);
+                var warningActions = new HashSet<string>();
+                if (ExecutionContext.Global.Variables.TryGetValue("Node12ActionsWarnings", out var node12Warnings))
+                {
+                    warningActions = StringUtil.ConvertFromJson<HashSet<string>>(node12Warnings);
+                }
+
+                var repoActionFullName = "";
+                if (string.IsNullOrEmpty(repoAction.Name))
+                {
+                    repoActionFullName = repoAction.Path; // local actions don't have a 'Name'
+                }
+                else
+                {
+                    repoActionFullName = $"{repoAction.Name}/{repoAction.Path ?? string.Empty}".TrimEnd('/') + $"@{repoAction.Ref}";
+                }
+
+                warningActions.Add(repoActionFullName);
+                ExecutionContext.Global.Variables.Set("Node12ActionsWarnings", StringUtil.ConvertToJson(warningActions));
             }
 
             using (var stdoutManager = new OutputManager(ExecutionContext, ActionCommandManager))

src/Runner.Worker/Handlers/OutputManager.cs

@@ -16,16 +16,16 @@ namespace GitHub.Runner.Worker.Handlers
         private const string _colorCodePrefix = "\033[";
         private const int _maxAttempts = 3;
         private const string _timeoutKey = "GITHUB_ACTIONS_RUNNER_ISSUE_MATCHER_TIMEOUT";
-        private static readonly Regex _colorCodeRegex = new Regex(@"\x0033\[[0-9;]*m?", RegexOptions.Compiled | RegexOptions.CultureInvariant);
+        private static readonly Regex _colorCodeRegex = new(@"\x0033\[[0-9;]*m?", RegexOptions.Compiled | RegexOptions.CultureInvariant);
         private readonly IActionCommandManager _commandManager;
         private readonly ContainerInfo _container;
         private readonly IExecutionContext _executionContext;
         private readonly int _failsafe = 50;
-        private readonly object _matchersLock = new object();
+        private readonly object _matchersLock = new();
         private readonly TimeSpan _timeout;
         private IssueMatcher[] _matchers = Array.Empty<IssueMatcher>();
         // Mapping that indicates whether a directory belongs to the workflow repository
-        private readonly Dictionary<string, string> _directoryMap = new Dictionary<string, string>();
+        private readonly Dictionary<string, string> _directoryMap = new();
 
         public OutputManager(IExecutionContext executionContext, IActionCommandManager commandManager, ContainerInfo container = null)
         {

src/Runner.Worker/Handlers/ScriptHandlerHelpers.cs

@@ -10,7 +10,7 @@ namespace GitHub.Runner.Worker.Handlers
 {
     internal static class ScriptHandlerHelpers
     {
-        private static readonly Dictionary<string, string> _defaultArguments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        private static readonly Dictionary<string, string> _defaultArguments = new(StringComparer.OrdinalIgnoreCase)
         {
             ["cmd"] = "/D /E:ON /V:OFF /S /C \"CALL \"{0}\"\"",
             ["pwsh"] = "-command \". '{0}'\"",
@@ -20,7 +20,7 @@ namespace GitHub.Runner.Worker.Handlers
             ["python"] = "{0}"
         };
 
-        private static readonly Dictionary<string, string> _extensions = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        private static readonly Dictionary<string, string> _extensions = new(StringComparer.OrdinalIgnoreCase)
         {
             ["cmd"] = ".cmd",
             ["pwsh"] = ".ps1",

src/Runner.Worker/JobExtension.cs

@@ -39,10 +39,10 @@ namespace GitHub.Runner.Worker
 
     public sealed class JobExtension : RunnerService, IJobExtension
     {
-        private readonly HashSet<string> _existingProcesses = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        private readonly HashSet<string> _existingProcesses = new(StringComparer.OrdinalIgnoreCase);
         private bool _processCleanup;
         private string _processLookupId = $"github_{Guid.NewGuid()}";
-        private CancellationTokenSource _diskSpaceCheckToken = new CancellationTokenSource();
+        private CancellationTokenSource _diskSpaceCheckToken = new();
         private Task _diskSpaceCheckTask = null;
 
         // Download all required actions.
@@ -59,8 +59,8 @@ namespace GitHub.Runner.Worker
             context.StepTelemetry.Type = "runner";
             context.StepTelemetry.Action = "setup_job";
 
-            List<IStep> preJobSteps = new List<IStep>();
-            List<IStep> jobSteps = new List<IStep>();
+            List<IStep> preJobSteps = new();
+            List<IStep> jobSteps = new();
             using (var register = jobContext.CancellationToken.Register(() => { context.CancelToken(); }))
             {
                 try
@@ -220,6 +220,11 @@ namespace GitHub.Runner.Worker
                         {
                             var networkAlias = pair.Key;
                             var serviceContainer = pair.Value;
+                            if (serviceContainer == null)
+                            {
+                                context.Output($"The service '{networkAlias}' will not be started because the container definition has an empty image.");
+                                continue;
+                            }
                             jobContext.Global.ServiceContainers.Add(new Container.ContainerInfo(HostContext, serviceContainer, false, networkAlias));
                         }
                     }
@@ -316,7 +321,10 @@ namespace GitHub.Runner.Worker
 
                     if (message.Variables.TryGetValue("system.workflowFileFullPath", out VariableValue workflowFileFullPath))
                     {
-                        context.Output($"Uses: {workflowFileFullPath.Value}");
+                        var usesLogText = $"Uses: {workflowFileFullPath.Value}";
+                        var reference = GetWorkflowReference(message.Variables);
+                        context.Output(usesLogText + reference);
+
                         if (message.ContextData.TryGetValue("inputs", out var pipelineContextData))
                         {
                             var inputs = pipelineContextData.AssertDictionary("inputs");
@@ -330,12 +338,12 @@ namespace GitHub.Runner.Worker
                                 context.Output("##[endgroup]");
                             }
                         }
+                    }
 
                     if (!string.IsNullOrWhiteSpace(message.JobDisplayName))
                     {
                         context.Output($"Complete job name: {message.JobDisplayName}");
                     }
-                    }
 
                     var intraActionStates = new Dictionary<Guid, Dictionary<string, string>>();
                     foreach (var preStep in prepareResult.PreStepTracker)
@@ -386,7 +394,7 @@ namespace GitHub.Runner.Worker
                                                                           data: (object)jobHookData));
                     }
 
-                    List<IStep> steps = new List<IStep>();
+                    List<IStep> steps = new();
                     steps.AddRange(preJobSteps);
                     steps.AddRange(jobSteps);
 
@@ -447,6 +455,24 @@ namespace GitHub.Runner.Worker
             }
         }
 
+        private string GetWorkflowReference(IDictionary<string, VariableValue> variables)
+        {
+            var reference = "";
+            if (variables.TryGetValue("system.workflowFileSha", out VariableValue workflowFileSha))
+            {
+                if (variables.TryGetValue("system.workflowFileRef", out VariableValue workflowFileRef)
+                    && !string.IsNullOrEmpty(workflowFileRef.Value))
+                {
+                    reference += $"@{workflowFileRef.Value} ({workflowFileSha.Value})";
+                }
+                else
+                {
+                    reference += $"@{workflowFileSha.Value}";
+                }
+            }
+            return reference;
+        }
+
         public void FinalizeJob(IExecutionContext jobContext, Pipelines.AgentJobRequestMessage message, DateTime jobStartTimeUtc)
         {
             Trace.Entering();
@@ -674,7 +700,7 @@ namespace GitHub.Runner.Worker
 
         private Dictionary<int, Process> SnapshotProcesses()
         {
-            Dictionary<int, Process> snapshot = new Dictionary<int, Process>();
+            Dictionary<int, Process> snapshot = new();
             foreach (var proc in Process.GetProcesses())
             {
                 try

src/Runner.Worker/JobRunner.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -258,9 +258,9 @@ namespace GitHub.Runner.Worker
                 }
             }
 
-            if (jobContext.JobContext.ContainsKey("Node12ActionsWarnings"))
+            if (jobContext.Global.Variables.TryGetValue("Node12ActionsWarnings", out var node12Warnings))
             {
-                var actions = string.Join(", ", jobContext.JobContext["Node12ActionsWarnings"].AssertArray("Node12ActionsWarnings").Select(action => action.ToString()));
+                var actions = string.Join(", ", StringUtil.ConvertFromJson<HashSet<string>>(node12Warnings));
                 jobContext.Warning(string.Format(Constants.Runner.Node12DetectedAfterEndOfLife, actions));
             }
 

src/Runner.Worker/Program.cs

@@ -11,7 +11,7 @@ namespace GitHub.Runner.Worker
     {
         public static int Main(string[] args)
         {
-            using (HostContext context = new HostContext("Worker"))
+            using (HostContext context = new("Worker"))
             {
                 return MainAsync(context, args).GetAwaiter().GetResult();
             }

src/Runner.Worker/RunnerPluginManager.cs

@@ -26,7 +26,7 @@ namespace GitHub.Runner.Worker
 
     public sealed class RunnerPluginManager : RunnerService, IRunnerPluginManager
     {
-        private readonly Dictionary<string, RunnerPluginActionInfo> _actionPlugins = new Dictionary<string, RunnerPluginActionInfo>(StringComparer.OrdinalIgnoreCase)
+        private readonly Dictionary<string, RunnerPluginActionInfo> _actionPlugins = new(StringComparer.OrdinalIgnoreCase)
         {
             {
                 "checkout",
@@ -97,7 +97,7 @@ namespace GitHub.Runner.Worker
             string arguments = $"action \"{plugin}\"";
 
             // construct plugin context
-            RunnerActionPluginExecutionContext pluginContext = new RunnerActionPluginExecutionContext
+            RunnerActionPluginExecutionContext pluginContext = new()
             {
                 Inputs = inputs,
                 Endpoints = context.Global.Endpoints,

src/Runner.Worker/StepsContext.cs

@@ -16,8 +16,8 @@ namespace GitHub.Runner.Worker
     /// </summary>
     public sealed class StepsContext
     {
-        private static readonly Regex _propertyRegex = new Regex("^[a-zA-Z_][a-zA-Z0-9_]*$", RegexOptions.Compiled);
-        private readonly DictionaryContextData _contextData = new DictionaryContextData();
+        private static readonly Regex _propertyRegex = new("^[a-zA-Z_][a-zA-Z0-9_]*$", RegexOptions.Compiled);
+        private readonly DictionaryContextData _contextData = new();
 
         /// <summary>
         /// Clears memory for a composite action's isolated "steps" context, after the action

src/Runner.Worker/TrackingManager.cs

@@ -32,7 +32,7 @@ namespace GitHub.Runner.Worker
             Trace.Entering();
 
             // Create the new tracking config.
-            TrackingConfig config = new TrackingConfig(executionContext);
+            TrackingConfig config = new(executionContext);
             WriteToFile(file, config);
             return config;
         }

src/Runner.Worker/Variables.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using GitHub.DistributedTask.WebApi;
 using GitHub.DistributedTask.Logging;
 using GitHub.DistributedTask.Pipelines.ContextData;
+using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
@@ -14,9 +14,9 @@ namespace GitHub.Runner.Worker
     public sealed class Variables
     {
         private readonly IHostContext _hostContext;
-        private readonly ConcurrentDictionary<string, Variable> _variables = new ConcurrentDictionary<string, Variable>(StringComparer.OrdinalIgnoreCase);
+        private readonly ConcurrentDictionary<string, Variable> _variables = new(StringComparer.OrdinalIgnoreCase);
         private readonly ISecretMasker _secretMasker;
-        private readonly object _setLock = new object();
+        private readonly object _setLock = new();
         private readonly Tracing _trace;
 
         public IEnumerable<Variable> AllVariables
@@ -43,7 +43,7 @@ namespace GitHub.Runner.Worker
             }
 
             // Initialize the variable dictionary.
-            List<Variable> variables = new List<Variable>();
+            List<Variable> variables = new();
             foreach (var variable in copy)
             {
                 if (!string.IsNullOrWhiteSpace(variable.Key))
@@ -136,6 +136,12 @@ namespace GitHub.Runner.Worker
             return null;
         }
 
+        public void Set(string name, string val)
+        {
+            ArgUtil.NotNullOrEmpty(name, nameof(name));
+            _variables[name] = new Variable(name, val, false);
+        }
+
         public bool TryGetValue(string name, out string val)
         {
             Variable variable;

src/Runner.Worker/Worker.cs

@@ -22,10 +22,10 @@ namespace GitHub.Runner.Worker
     public sealed class Worker : RunnerService, IWorker
     {
         private readonly TimeSpan _workerStartTimeout = TimeSpan.FromSeconds(30);
-        private ManualResetEvent _completedCommand = new ManualResetEvent(false);
+        private ManualResetEvent _completedCommand = new(false);
 
         // Do not mask the values of these secrets
-        private static HashSet<String> SecretVariableMaskWhitelist = new HashSet<String>(StringComparer.OrdinalIgnoreCase)
+        private static HashSet<String> SecretVariableMaskWhitelist = new(StringComparer.OrdinalIgnoreCase)
         {
             Constants.Variables.Actions.StepDebug,
             Constants.Variables.Actions.RunnerDebug

src/Sdk/Common/Common/Authentication/VssCredentialsExtension.cs

@@ -0,0 +1,20 @@
+using GitHub.Services.OAuth;
+
+namespace GitHub.Services.Common
+{
+    public static class VssCredentialsExtension
+    {
+        public static VssOAuthCredential ToOAuthCredentials(
+            this VssCredentials credentials)
+        {
+            if (credentials.Federated.CredentialType == VssCredentialsType.OAuth)
+            {
+                return credentials.Federated as VssOAuthCredential;
+            }
+            else
+            {
+                return null;
+            }
+        }
+    }
+}