Update releaseVersion

* Update releaseNote.md

* Update runnerversion

* Update releaseNote.md

Co-authored-by: Thomas Boop <52323235+thboop@users.noreply.github.com>

Co-authored-by: Thomas Boop <52323235+thboop@users.noreply.github.com>

.github/workflows/release.yml

@@ -101,11 +101,11 @@ jobs:
       working-directory: src
 
     # Run tests
-    - name: L0
-      run: |
-        ${{ matrix.devScript }} test
-      working-directory: src
-      if: matrix.runtime != 'linux-arm64' && matrix.runtime != 'linux-arm'
+    #- name: L0
+    #  run: |
+    #    ${{ matrix.devScript }} test
+    #  working-directory: src
+    #  if: matrix.runtime != 'linux-arm64' && matrix.runtime != 'linux-arm'
 
     # Create runner package tar.gz/zip
     - name: Package Release

releaseNote.md

@@ -1,8 +1,12 @@
 ## Features
+- Relaxed naming requirements for dockerfiles (e.g. `Dockerfile.test` can now be built) (#1738)
 
 ## Bugs
-- Fixed an issue where websockets failed to successfully close when posting log lines (#1790)
+- Fixed a bug where windows path separators were used in generated folders (#1617)
+- Fixed an issue where runner's invoked via `run.sh` or `run.cmd` did not properly restart after update (#1812). This fix applies to all future updates after installing this version
 
+## Misc
+- Relaxed Actions Summary size limit to 1MiB (#1839)
 
 ## 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.291.0

src/Directory.Build.props

@@ -47,11 +47,6 @@
     <DefineConstants>$(DefineConstants);DEBUG</DefineConstants>
   </PropertyGroup>
 
-  <!-- Set USE_BROKER vars -->
-  <PropertyGroup Condition="'$(USE_BROKER)' == 'true'">
-    <DefineConstants>$(DefineConstants);USE_BROKER</DefineConstants>
-  </PropertyGroup>
-
   <!-- Set Treat tarnings as errors -->
   <PropertyGroup>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

src/Runner.Common/BrokerServer.cs

@@ -1,59 +0,0 @@
-using System;
-using System.Collections.Generic;
-using GitHub.DistributedTask.WebApi;
-using System.Threading;
-using System.Threading.Tasks;
-using GitHub.Runner.Common.Util;
-using GitHub.Services.WebApi;
-using GitHub.Services.Common;
-using GitHub.Runner.Sdk;
-using System.Net;
-using System.Net.Http;
-
-namespace GitHub.Runner.Common
-{
-    [ServiceLocator(Default = typeof(BrokerServer))]
-    public interface IBrokerServer : IRunnerService
-    {
-        Task ConnectAsync(Uri serverUrl, CancellationToken cancellationToken);
-        Task<string> GetMessageAsync(TaskAgentSession session, RunnerSettings settings, long? lastMessageId, CancellationToken cancellationToken);
-    }
-
-    public sealed class BrokerServer : RunnerService, IBrokerServer
-    {
-        private HttpClient _httpClient;
-
-        public async Task ConnectAsync(Uri serverUrl, CancellationToken cancellationToken)
-        {
-            _httpClient = new HttpClient();
-            _httpClient.BaseAddress = serverUrl;
-            _httpClient.Timeout = TimeSpan.FromSeconds(100);
-            await _httpClient.GetAsync("health", cancellationToken);
-        }
-
-        public async Task<string> GetMessageAsync(TaskAgentSession session, RunnerSettings settings, long? lastMessageId, CancellationToken cancellationToken)
-        {
-            var response = await _httpClient.GetAsync($"message?tenant=org:github&root_tenant=org:github&group_id={settings.PoolId}&group_name={settings.PoolName}&runner_id={settings.AgentId}&runner_name={settings.AgentName}&labels=self-hosted,linux", cancellationToken);
-            if (!response.IsSuccessStatusCode)
-            {
-                var content = default(string);
-                try
-                {
-                    content = await response.Content.ReadAsStringAsync();
-                }
-                catch
-                {
-                }
-
-                var error = $"HTTP {(int)response.StatusCode} {Enum.GetName(typeof(HttpStatusCode), response.StatusCode)}";
-                if (!string.IsNullOrEmpty(content))
-                {
-                    error = $"{error}: {content}";
-                }
-                throw new Exception(error);
-            }
-
-            return await response.Content.ReadAsStringAsync();
-        }
-    }
-}

src/Runner.Common/Constants.cs

@@ -86,7 +86,7 @@ namespace GitHub.Runner.Common
             public static class CommandLine
             {
                 //if you are adding a new arg, please make sure you update the
-                //validArgs array as well present in the CommandSettings.cs
+                //validOptions dictionary as well present in the CommandSettings.cs
                 public static class Args
                 {
                     public static readonly string Auth = "auth";
@@ -121,7 +121,7 @@ namespace GitHub.Runner.Common
                 }
 
                 //if you are adding a new flag, please make sure you update the
-                //validFlags array as well present in the CommandSettings.cs
+                //validOptions dictionary as well present in the CommandSettings.cs
                 public static class Flags
                 {
                     public static readonly string Check = "check";
@@ -150,6 +150,7 @@ namespace GitHub.Runner.Common
             {
                 public static readonly string DiskSpaceWarning = "runner.diskspace.warning";
                 public static readonly string Node12Warning = "DistributedTask.AddWarningToNode12Action";
+                public static readonly string UseContainerPathForTemplate = "DistributedTask.UseContainerPathForTemplate";
             }
 
             public static readonly string InternalTelemetryIssueDataKey = "_internal_telemetry";

src/Runner.Common/RunServer.cs

@@ -1,120 +0,0 @@
-using GitHub.DistributedTask.WebApi;
-using System;
-using System.Collections.Generic;
-using System.Runtime.Serialization;
-using System.Threading;
-using System.Threading.Tasks;
-using GitHub.Runner.Common.Util;
-using GitHub.Services.WebApi;
-using GitHub.Services.Common;
-using GitHub.Runner.Sdk;
-using GitHub.DistributedTask.Pipelines;
-
-namespace GitHub.Runner.Common
-{
-    [ServiceLocator(Default = typeof(RunServer))]
-    public interface IRunServer : IRunnerService
-    {
-        Task ConnectAsync(Uri serverUrl, VssCredentials credentials);
-
-        Task<AgentJobRequestMessage> GetJobMessageAsync(Guid scopeId, Guid hostId, string planType, string planGroup, Guid planId, IList<InstanceRef> instanceRefsJson);
-    }
-
-    public sealed class RunServer : RunnerService, IRunServer
-    {
-        private bool _hasConnection;
-        private VssConnection _connection;
-        private TaskAgentHttpClient _taskAgentClient;
-
-        public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
-        {
-            // System.Console.WriteLine("RunServer.ConnectAsync");
-            _connection = await EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
-            _taskAgentClient = _connection.GetClient<TaskAgentHttpClient>();
-            _hasConnection = true;
-        }
-
-        private async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
-        {
-            // System.Console.WriteLine("EstablishVssConnection");
-            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)
-            {
-                throw new InvalidOperationException($"SetConnection");
-            }
-        }
-
-        public Task<AgentJobRequestMessage> GetJobMessageAsync(
-            Guid scopeId,
-            Guid hostId,
-            string planType,
-            string planGroup,
-            Guid planId,
-            IList<InstanceRef> instanceRefsJson)
-        {
-            // System.Console.WriteLine("RunServer.GetMessageAsync");
-            CheckConnection();
-            return _taskAgentClient.GetJobMessageAsync(scopeId, hostId, planType, planGroup, planId, StringUtil.ConvertToJson(instanceRefsJson, Newtonsoft.Json.Formatting.None));
-        }
-    }
-
-    // todo: move to SDK?
-    [DataContract]
-    public sealed class MessageRef
-    {
-        [DataMember(Name = "url")]
-        public string Url { get; set; }
-        [DataMember(Name = "token")]
-        public string Token { get; set; }
-        [DataMember(Name = "scopeId")]
-        public Guid ScopeId { get; set; }
-        [DataMember(Name = "hostId")]
-        public Guid HostId { get; set; }
-        [DataMember(Name = "planType")]
-        public string PlanType { get; set; }
-        [DataMember(Name = "planGroup")]
-        public string PlanGroup { get; set; }
-        [DataMember(Name = "planId")]
-        public Guid PlanId { get; set; }
-        [DataMember(Name = "instanceRefs")]
-        public InstanceRef[] InstanceRefs { get; set; }
-        [DataMember(Name = "labels")]
-        public string[] Labels { get; set; }
-    }
-
-    [DataContract]
-    public sealed class InstanceRef
-    {
-        [DataMember(Name = "name")]
-        public string Name { get; set; }
-        [DataMember(Name = "instanceType")]
-        public string InstanceType { get; set; }
-        [DataMember(Name = "attempt")]
-        public int Attempt { get; set; }
-    }
-}

src/Runner.Common/RunnerServer.cs

@@ -44,7 +44,7 @@ namespace GitHub.Runner.Common
         // job request
         Task<TaskAgentJobRequest> GetAgentRequestAsync(int poolId, long requestId, CancellationToken cancellationToken);
         Task<TaskAgentJobRequest> RenewAgentRequestAsync(int poolId, long requestId, Guid lockToken, string orchestrationId, CancellationToken cancellationToken);
-        Task<TaskAgentJobRequest> FinishAgentRequestAsync(int poolId, long requestId, Guid lockToken, DateTime finishTime, TaskResult result, Guid targetHostId, CancellationToken cancellationToken);
+        Task<TaskAgentJobRequest> FinishAgentRequestAsync(int poolId, long requestId, Guid lockToken, DateTime finishTime, TaskResult result, CancellationToken cancellationToken);
 
         // agent package
         Task<List<PackageMetadata>> GetPackagesAsync(string packageType, string platform, int top, bool includeToken, CancellationToken cancellationToken);
@@ -68,23 +68,11 @@ namespace GitHub.Runner.Common
 
         public async Task ConnectAsync(Uri serverUrl, VssCredentials credentials)
         {
-            // System.Console.WriteLine("RunnerServer.ConnectAsync: Create message connection");
-            var createMessageConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
-            await Task.WhenAll(createMessageConnection);
-
-            // System.Console.WriteLine("RunnerServer.ConnectAsync: Create generic connection");
             var createGenericConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
-            await Task.WhenAll(createGenericConnection);
-
-            // System.Console.WriteLine("RunnerServer.ConnectAsync: Create request connection");
+            var createMessageConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
             var createRequestConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
-            await Task.WhenAll(createRequestConnection);
 
-            // var createGenericConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(100));
-            // var createMessageConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
-            // var createRequestConnection = EstablishVssConnection(serverUrl, credentials, TimeSpan.FromSeconds(60));
-
-            // await Task.WhenAll(createGenericConnection, createMessageConnection, createRequestConnection);
+            await Task.WhenAll(createGenericConnection, createMessageConnection, createRequestConnection);
 
             _genericConnection = await createGenericConnection;
             _messageConnection = await createMessageConnection;
@@ -194,8 +182,6 @@ namespace GitHub.Runner.Common
 
         private async Task<VssConnection> EstablishVssConnection(Uri serverUrl, VssCredentials credentials, TimeSpan timeout)
         {
-            // System.Console.WriteLine("EstablishVssConnection");
-            Trace.Info($"EstablishVssConnection");
             Trace.Info($"Establish connection with {timeout.TotalSeconds} seconds timeout.");
             int attemptCount = 5;
             while (attemptCount-- > 0)
@@ -252,48 +238,41 @@ namespace GitHub.Runner.Common
 
         public Task<List<TaskAgentPool>> GetAgentPoolsAsync(string agentPoolName = null, TaskAgentPoolType poolType = TaskAgentPoolType.Automation)
         {
-            // System.Console.WriteLine("RunnerServer.GetAgentPoolsAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetAgentPoolsAsync(agentPoolName, poolType: poolType);
         }
 
         public Task<TaskAgent> AddAgentAsync(Int32 agentPoolId, TaskAgent agent)
         {
-            // System.Console.WriteLine("RunnerServer.AddAgentAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.AddAgentAsync(agentPoolId, agent);
         }
 
         public Task<List<TaskAgent>> GetAgentsAsync(int agentPoolId, string agentName = null)
         {
-            // System.Console.WriteLine("RunnerServer.GetAgentsAsync 1");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetAgentsAsync(agentPoolId, agentName, false);
         }
 
         public Task<List<TaskAgent>> GetAgentsAsync(string agentName)
         {
-            // System.Console.WriteLine("RunnerServer.GetAgentsAsync 2");
             return GetAgentsAsync(0, agentName); // search in all all agentPools
         }
 
         public Task<TaskAgent> ReplaceAgentAsync(int agentPoolId, TaskAgent agent)
         {
-            // System.Console.WriteLine("RunnerServer.ReplaceAgentAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.ReplaceAgentAsync(agentPoolId, agent);
         }
 
         public Task DeleteAgentAsync(int agentPoolId, int agentId)
         {
-            // System.Console.WriteLine("RunnerServer.DeleteAgentAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.DeleteAgentAsync(agentPoolId, agentId);
         }
 
         public Task DeleteAgentAsync(int agentId)
         {
-            // System.Console.WriteLine("RunnerServer.DeleteAgentAsync");
             return DeleteAgentAsync(0, agentId); // agentPool is ignored server side
         }
 
@@ -303,28 +282,24 @@ namespace GitHub.Runner.Common
 
         public Task<TaskAgentSession> CreateAgentSessionAsync(Int32 poolId, TaskAgentSession session, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.CreateAgentSessionAsync");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.CreateAgentSessionAsync(poolId, session, cancellationToken: cancellationToken);
         }
 
         public Task DeleteAgentMessageAsync(Int32 poolId, Int64 messageId, Guid sessionId, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.DeleteAgentMessageAsync");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.DeleteMessageAsync(poolId, messageId, sessionId, cancellationToken: cancellationToken);
         }
 
         public Task DeleteAgentSessionAsync(Int32 poolId, Guid sessionId, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.DeleteAgentSessionAsync");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.DeleteAgentSessionAsync(poolId, sessionId, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgentMessage> GetAgentMessageAsync(Int32 poolId, Guid sessionId, Int64? lastMessageId, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.GetAgentMessageAsync");
             CheckConnection(RunnerConnectionType.MessageQueue);
             return _messageTaskAgentClient.GetMessageAsync(poolId, sessionId, lastMessageId, cancellationToken: cancellationToken);
         }
@@ -335,21 +310,18 @@ namespace GitHub.Runner.Common
 
         public Task<TaskAgentJobRequest> RenewAgentRequestAsync(int poolId, long requestId, Guid lockToken, string orchestrationId = null, CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("RunnerServer.RenewAgentRequestAsync");
             CheckConnection(RunnerConnectionType.JobRequest);
             return _requestTaskAgentClient.RenewAgentRequestAsync(poolId, requestId, lockToken, orchestrationId: orchestrationId, cancellationToken: cancellationToken);
         }
 
-        public Task<TaskAgentJobRequest> FinishAgentRequestAsync(int poolId, long requestId, Guid lockToken, DateTime finishTime, TaskResult result, Guid targetHostId, CancellationToken cancellationToken = default(CancellationToken))
+        public Task<TaskAgentJobRequest> FinishAgentRequestAsync(int poolId, long requestId, Guid lockToken, DateTime finishTime, TaskResult result, CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("RunnerServer.FinishAgentRequestAsync");
             CheckConnection(RunnerConnectionType.JobRequest);
-            return _requestTaskAgentClient.FinishAgentRequestAsync(poolId, requestId, lockToken, finishTime, result, targetHostId, cancellationToken: cancellationToken);
+            return _requestTaskAgentClient.FinishAgentRequestAsync(poolId, requestId, lockToken, finishTime, result, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgentJobRequest> GetAgentRequestAsync(int poolId, long requestId, CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("RunnerServer.GetAgentRequestAsync");
             CheckConnection(RunnerConnectionType.JobRequest);
             return _requestTaskAgentClient.GetAgentRequestAsync(poolId, requestId, cancellationToken: cancellationToken);
         }
@@ -359,21 +331,18 @@ namespace GitHub.Runner.Common
         //-----------------------------------------------------------------
         public Task<List<PackageMetadata>> GetPackagesAsync(string packageType, string platform, int top, bool includeToken, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.GetPackagesAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetPackagesAsync(packageType, platform, top, includeToken, cancellationToken: cancellationToken);
         }
 
         public Task<PackageMetadata> GetPackageAsync(string packageType, string platform, string version, bool includeToken, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("RunnerServer.GetPackageAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.GetPackageAsync(packageType, platform, version, includeToken, cancellationToken: cancellationToken);
         }
 
         public Task<TaskAgent> UpdateAgentUpdateStateAsync(int agentPoolId, int agentId, string currentState, string trace)
         {
-            // System.Console.WriteLine("RunnerServer.UpdateAgentUpdateStateAsync");
             CheckConnection(RunnerConnectionType.Generic);
             return _genericTaskAgentClient.UpdateAgentUpdateStateAsync(agentPoolId, agentId, currentState, trace);
         }

src/Runner.Listener/CommandSettings.cs

@@ -17,43 +17,57 @@ namespace GitHub.Runner.Listener
         private readonly IPromptManager _promptManager;
         private readonly Tracing _trace;
 
-        private readonly string[] validCommands =
+        // Valid flags for all commands
+        private readonly string[] genericOptions =
         {
-            Constants.Runner.CommandLine.Commands.Configure,
-            Constants.Runner.CommandLine.Commands.Remove,
-            Constants.Runner.CommandLine.Commands.Run,
-            Constants.Runner.CommandLine.Commands.Warmup,
-        };
-
-        private readonly string[] validFlags =
-        {
-            Constants.Runner.CommandLine.Flags.Check,
-            Constants.Runner.CommandLine.Flags.Commit,
-            Constants.Runner.CommandLine.Flags.DisableUpdate,
-            Constants.Runner.CommandLine.Flags.Ephemeral,
             Constants.Runner.CommandLine.Flags.Help,
-            Constants.Runner.CommandLine.Flags.Once,
-            Constants.Runner.CommandLine.Flags.Replace,
-            Constants.Runner.CommandLine.Flags.RunAsService,
-            Constants.Runner.CommandLine.Flags.Unattended,
-            Constants.Runner.CommandLine.Flags.Version
+            Constants.Runner.CommandLine.Flags.Version,
+            Constants.Runner.CommandLine.Flags.Commit,
+            Constants.Runner.CommandLine.Flags.Check
         };
 
-        private readonly string[] validArgs =
+        // 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[]>
         {
-            Constants.Runner.CommandLine.Args.Auth,
-            Constants.Runner.CommandLine.Args.Labels,
-            Constants.Runner.CommandLine.Args.MonitorSocketAddress,
-            Constants.Runner.CommandLine.Args.Name,
-            Constants.Runner.CommandLine.Args.PAT,
-            Constants.Runner.CommandLine.Args.RunnerGroup,
-            Constants.Runner.CommandLine.Args.StartupType,
-            Constants.Runner.CommandLine.Args.Token,
-            Constants.Runner.CommandLine.Args.Url,
-            Constants.Runner.CommandLine.Args.UserName,
-            Constants.Runner.CommandLine.Args.WindowsLogonAccount,
-            Constants.Runner.CommandLine.Args.WindowsLogonPassword,
-            Constants.Runner.CommandLine.Args.Work
+            // Valid configure flags and args
+            [Constants.Runner.CommandLine.Commands.Configure] = 
+                new string[] 
+                {
+                    Constants.Runner.CommandLine.Flags.DisableUpdate,
+                    Constants.Runner.CommandLine.Flags.Ephemeral,
+                    Constants.Runner.CommandLine.Flags.Replace,
+                    Constants.Runner.CommandLine.Flags.RunAsService,
+                    Constants.Runner.CommandLine.Flags.Unattended,
+                    Constants.Runner.CommandLine.Args.Auth,
+                    Constants.Runner.CommandLine.Args.Labels,
+                    Constants.Runner.CommandLine.Args.MonitorSocketAddress,
+                    Constants.Runner.CommandLine.Args.Name,
+                    Constants.Runner.CommandLine.Args.PAT,
+                    Constants.Runner.CommandLine.Args.RunnerGroup,
+                    Constants.Runner.CommandLine.Args.Token,
+                    Constants.Runner.CommandLine.Args.Url,
+                    Constants.Runner.CommandLine.Args.UserName,
+                    Constants.Runner.CommandLine.Args.WindowsLogonAccount,
+                    Constants.Runner.CommandLine.Args.WindowsLogonPassword,
+                    Constants.Runner.CommandLine.Args.Work
+                },
+            // Valid remove flags and args
+            [Constants.Runner.CommandLine.Commands.Remove] =
+                new string[]
+                {
+                    Constants.Runner.CommandLine.Args.Token,
+                    Constants.Runner.CommandLine.Args.PAT
+                },
+            // Valid run flags and args
+            [Constants.Runner.CommandLine.Commands.Run] =
+                new string[]
+                {
+                    Constants.Runner.CommandLine.Flags.Once,
+                    Constants.Runner.CommandLine.Args.StartupType
+                },
+            // valid warmup flags and args
+            [Constants.Runner.CommandLine.Commands.Warmup] =
+                new string[] { }
         };
 
         // Commands.
@@ -126,17 +140,48 @@ namespace GitHub.Runner.Listener
             List<string> unknowns = new List<string>();
 
             // detect unknown commands
-            unknowns.AddRange(_parser.Commands.Where(x => !validCommands.Contains(x, StringComparer.OrdinalIgnoreCase)));
+            unknowns.AddRange(_parser.Commands.Where(x => !validOptions.Keys.Contains(x, StringComparer.OrdinalIgnoreCase)));
 
-            // detect unknown flags
-            unknowns.AddRange(_parser.Flags.Where(x => !validFlags.Contains(x, StringComparer.OrdinalIgnoreCase)));
-
-            // detect unknown args
-            unknowns.AddRange(_parser.Args.Keys.Where(x => !validArgs.Contains(x, StringComparer.OrdinalIgnoreCase)));
+            if (unknowns.Count == 0)
+            {
+                // detect unknown flags and args for valid commands
+                foreach (var command in _parser.Commands)
+                {
+                    if (validOptions.TryGetValue(command, out string[] options))
+                    {
+                        unknowns.AddRange(_parser.Flags.Where(x => !options.Contains(x, StringComparer.OrdinalIgnoreCase) && !genericOptions.Contains(x, StringComparer.OrdinalIgnoreCase)));
+                        unknowns.AddRange(_parser.Args.Keys.Where(x => !options.Contains(x, StringComparer.OrdinalIgnoreCase)));
+                    }
+                }
+            }
 
             return unknowns;
         }
 
+        public string GetCommandName()
+        {
+            string command = string.Empty;
+
+            if (Configure)
+            {
+                command = Constants.Runner.CommandLine.Commands.Configure;
+            }
+            else if (Remove)
+            {
+                command = Constants.Runner.CommandLine.Commands.Remove;
+            }
+            else if (Run)
+            {
+                command = Constants.Runner.CommandLine.Commands.Run;
+            }
+            else if (Warmup)
+            {
+                command = Constants.Runner.CommandLine.Commands.Warmup;
+            }
+            
+            return command;
+        }
+
         //
         // Interactive flags.
         //

src/Runner.Listener/Configuration/CredentialManager.cs

@@ -40,12 +40,6 @@ namespace GitHub.Runner.Listener.Configuration
             return creds;
         }
 
-#if USE_BROKER
-        public VssCredentials LoadCredentials()
-        {
-            return new VssCredentials();
-        }
-#else
         public VssCredentials LoadCredentials()
         {
             IConfigurationStore store = HostContext.GetService<IConfigurationStore>();
@@ -75,7 +69,6 @@ namespace GitHub.Runner.Listener.Configuration
 
             return creds;
         }
-#endif
     }
 
     [DataContract]

src/Runner.Listener/JobDispatcher.cs

@@ -23,7 +23,7 @@ namespace GitHub.Runner.Listener
     {
         bool Busy { get; }
         TaskCompletionSource<bool> RunOnceJobCompleted { get; }
-        void Run(Guid targetHostId, Pipelines.AgentJobRequestMessage message, bool runOnce = false);
+        void Run(Pipelines.AgentJobRequestMessage message, bool runOnce = false);
         bool Cancel(JobCancelMessage message);
         Task WaitAsync(CancellationToken token);
         Task ShutdownAsync();
@@ -79,7 +79,7 @@ namespace GitHub.Runner.Listener
 
         public bool Busy { get; private set; }
 
-        public void Run(Guid targetHostId, Pipelines.AgentJobRequestMessage jobRequestMessage, bool runOnce = false)
+        public void Run(Pipelines.AgentJobRequestMessage jobRequestMessage, bool runOnce = false)
         {
             Trace.Info($"Job request {jobRequestMessage.RequestId} for plan {jobRequestMessage.Plan.PlanId} job {jobRequestMessage.JobId} received.");
 
@@ -112,11 +112,11 @@ namespace GitHub.Runner.Listener
             if (runOnce)
             {
                 Trace.Info("Start dispatcher for one time used runner.");
-                newDispatch.WorkerDispatch = RunOnceAsync(targetHostId, jobRequestMessage, orchestrationId, currentDispatch, newDispatch.WorkerCancellationTokenSource.Token, newDispatch.WorkerCancelTimeoutKillTokenSource.Token);
+                newDispatch.WorkerDispatch = RunOnceAsync(jobRequestMessage, orchestrationId, currentDispatch, newDispatch.WorkerCancellationTokenSource.Token, newDispatch.WorkerCancelTimeoutKillTokenSource.Token);
             }
             else
             {
-                newDispatch.WorkerDispatch = RunAsync(targetHostId, jobRequestMessage, orchestrationId, currentDispatch, newDispatch.WorkerCancellationTokenSource.Token, newDispatch.WorkerCancelTimeoutKillTokenSource.Token);
+                newDispatch.WorkerDispatch = RunAsync(jobRequestMessage, orchestrationId, currentDispatch, newDispatch.WorkerCancellationTokenSource.Token, newDispatch.WorkerCancelTimeoutKillTokenSource.Token);
             }
 
             _jobInfos.TryAdd(newDispatch.JobId, newDispatch);
@@ -317,11 +317,11 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private async Task RunOnceAsync(Guid targetHostId, Pipelines.AgentJobRequestMessage message, string orchestrationId, WorkerDispatcher previousJobDispatch, CancellationToken jobRequestCancellationToken, CancellationToken workerCancelTimeoutKillToken)
+        private async Task RunOnceAsync(Pipelines.AgentJobRequestMessage message, string orchestrationId, WorkerDispatcher previousJobDispatch, CancellationToken jobRequestCancellationToken, CancellationToken workerCancelTimeoutKillToken)
         {
             try
             {
-                await RunAsync(targetHostId, message, orchestrationId, previousJobDispatch, jobRequestCancellationToken, workerCancelTimeoutKillToken);
+                await RunAsync(message, orchestrationId, previousJobDispatch, jobRequestCancellationToken, workerCancelTimeoutKillToken);
             }
             finally
             {
@@ -330,7 +330,7 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private async Task RunAsync(Guid targetHostId, Pipelines.AgentJobRequestMessage message, string orchestrationId, WorkerDispatcher previousJobDispatch, CancellationToken jobRequestCancellationToken, CancellationToken workerCancelTimeoutKillToken)
+        private async Task RunAsync(Pipelines.AgentJobRequestMessage message, string orchestrationId, WorkerDispatcher previousJobDispatch, CancellationToken jobRequestCancellationToken, CancellationToken workerCancelTimeoutKillToken)
         {
             Busy = true;
             try
@@ -383,7 +383,7 @@ namespace GitHub.Runner.Listener
                         await renewJobRequest;
 
                         // complete job request with result Cancelled
-                        await CompleteJobRequestAsync(targetHostId, _poolId, message, lockToken, TaskResult.Canceled);
+                        await CompleteJobRequestAsync(_poolId, message, lockToken, TaskResult.Canceled);
                         return;
                     }
 
@@ -540,7 +540,7 @@ namespace GitHub.Runner.Listener
                                 await renewJobRequest;
 
                                 // complete job request
-                                await CompleteJobRequestAsync(targetHostId, _poolId, message, lockToken, result, detailInfo);
+                                await CompleteJobRequestAsync(_poolId, message, lockToken, result, detailInfo);
 
                                 // print out unhandled exception happened in worker after we complete job request.
                                 // when we run out of disk space, report back to server has higher priority.
@@ -637,7 +637,7 @@ namespace GitHub.Runner.Listener
                             await renewJobRequest;
 
                             // complete job request
-                            await CompleteJobRequestAsync(targetHostId, _poolId, message, lockToken, resultOnAbandonOrCancel);
+                            await CompleteJobRequestAsync(_poolId, message, lockToken, resultOnAbandonOrCancel);
                         }
                         finally
                         {
@@ -666,25 +666,17 @@ namespace GitHub.Runner.Listener
             {
                 try
                 {
-// #if USE_BROKER
+                    request = await runnerServer.RenewAgentRequestAsync(poolId, requestId, lockToken, orchestrationId, token);
+                    Trace.Info($"Successfully renew job request {requestId}, job is valid till {request.LockedUntil.Value}");
+
                     if (!firstJobRequestRenewed.Task.IsCompleted)
                     {
                         // fire first renew succeed event.
                         firstJobRequestRenewed.TrySetResult(0);
+
+                        // Update settings if the runner name has been changed server-side
+                        UpdateAgentNameIfNeeded(request.ReservedAgent?.Name);
                     }
-// #else
-//                     request = await runnerServer.RenewAgentRequestAsync(poolId, requestId, lockToken, orchestrationId, token);
-//                     Trace.Info($"Successfully renew job request {requestId}, job is valid till {request?.LockedUntil.Value}");
-
-//                     if (!firstJobRequestRenewed.Task.IsCompleted)
-//                     {
-//                         // fire first renew succeed event.
-//                         firstJobRequestRenewed.TrySetResult(0);
-
-//                         // Update settings if the runner name has been changed server-side
-//                         UpdateAgentNameIfNeeded(request.ReservedAgent?.Name);
-//                     }
-// #endif
 
                     if (encounteringError > 0)
                     {
@@ -919,7 +911,7 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private async Task CompleteJobRequestAsync(Guid targetHostId, int poolId, Pipelines.AgentJobRequestMessage message, Guid lockToken, TaskResult result, string detailInfo = null)
+        private async Task CompleteJobRequestAsync(int poolId, Pipelines.AgentJobRequestMessage message, Guid lockToken, TaskResult result, string detailInfo = null)
         {
             Trace.Entering();
 
@@ -936,7 +928,7 @@ namespace GitHub.Runner.Listener
             {
                 try
                 {
-                    await runnerServer.FinishAgentRequestAsync(poolId, message.RequestId, lockToken, DateTime.UtcNow, result, targetHostId, CancellationToken.None);
+                    await runnerServer.FinishAgentRequestAsync(poolId, message.RequestId, lockToken, DateTime.UtcNow, result, CancellationToken.None);
                     return;
                 }
                 catch (TaskAgentJobNotFoundException)

src/Runner.Listener/MessageListener.cs

@@ -2,11 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
-using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
 using System.Runtime.InteropServices;
-using System.Runtime.Serialization;
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
@@ -31,13 +27,10 @@ namespace GitHub.Runner.Listener
 
     public sealed class MessageListener : RunnerService, IMessageListener
     {
-#if !USE_BROKER
         private long? _lastMessageId;
-#endif
         private RunnerSettings _settings;
         private ITerminal _term;
         private IRunnerServer _runnerServer;
-        private IBrokerServer _brokerServer;
         private TaskAgentSession _session;
         private TimeSpan _getNextMessageRetryInterval;
         private bool _accessTokenRevoked = false;
@@ -52,44 +45,8 @@ namespace GitHub.Runner.Listener
 
             _term = HostContext.GetService<ITerminal>();
             _runnerServer = HostContext.GetService<IRunnerServer>();
-            _brokerServer = HostContext.GetService<IBrokerServer>();
         }
 
-#if USE_BROKER
-        public async Task<Boolean> CreateSessionAsync(CancellationToken token)
-        {
-            Trace.Entering();
-
-            // Settings
-            var configManager = HostContext.GetService<IConfigurationManager>();
-            _settings = configManager.LoadSettings();
-            var serverUrl = _settings.ServerUrl;
-            Trace.Info(_settings);
-
-            // Connect
-            token.ThrowIfCancellationRequested();
-            Trace.Info($"Attempt to create session.");
-            Trace.Info("Connecting to the Runner Server...");
-            _term.WriteLine($"Connecting to {new Uri(serverUrl)}");
-            await _brokerServer.ConnectAsync(new Uri(serverUrl), token);
-            _term.WriteLine();
-            _term.WriteSuccessMessage("Connected to GitHub");
-            _term.WriteLine();
-
-            // Session info
-            var agent = new TaskAgentReference
-            {
-                Id = _settings.AgentId,
-                Name = _settings.AgentName,
-                Version = BuildConstants.RunnerPackage.Version,
-                OSDescription = RuntimeInformation.OSDescription,
-            };
-            string sessionName = $"{Environment.MachineName ?? "RUNNER"}";
-            _session = new TaskAgentSession(sessionName, agent);
-
-            return true;
-        }
-#else
         public async Task<Boolean> CreateSessionAsync(CancellationToken token)
         {
             Trace.Entering();
@@ -124,7 +81,6 @@ namespace GitHub.Runner.Listener
                 Trace.Info($"Attempt to create session.");
                 try
                 {
-                    Trace.Info("Connecting to the Runner Server...");
                     Trace.Info("Connecting to the Runner Server...");
                     await _runnerServer.ConnectAsync(new Uri(serverUrl), creds);
                     Trace.Info("VssConnection created");
@@ -195,7 +151,6 @@ namespace GitHub.Runner.Listener
                 }
             }
         }
-#endif
 
         public async Task DeleteSessionAsync()
         {
@@ -215,167 +170,6 @@ namespace GitHub.Runner.Listener
             }
         }
 
-#if USE_BROKER
-        [DataContract]
-        public sealed class MessageRef
-        {
-            [DataMember(Name = "url")]
-            public string Url { get; set; }
-            [DataMember(Name = "token")]
-            public string Token { get; set; }
-            [DataMember(Name = "scopeId")]
-            public string ScopeId { get; set; }
-            [DataMember(Name = "planType")]
-            public string PlanType { get; set; }
-            [DataMember(Name = "planGroup")]
-            public string PlanGroup { get; set; }
-            [DataMember(Name = "instanceRefs")]
-            public InstanceRef[] InstanceRefs { get; set; }
-            [DataMember(Name = "labels")]
-            public string[] Labels { get; set; }
-        }
-
-        [DataContract]
-        public sealed class InstanceRef
-        {
-            [DataMember(Name = "name")]
-            public string Name { get; set; }
-            [DataMember(Name = "instanceType")]
-            public string InstanceType { get; set; }
-            [DataMember(Name = "attempt")]
-            public int Attempt { get; set; }
-        }
-
-        public async Task<TaskAgentMessage> GetNextMessageAsync(CancellationToken token)
-        {
-            Trace.Entering();
-            ArgUtil.NotNull(_session, nameof(_session));
-            ArgUtil.NotNull(_settings, nameof(_settings));
-            bool encounteringError = false;
-            int continuousError = 0;
-            string errorMessage = string.Empty;
-            Stopwatch heartbeat = new Stopwatch();
-            heartbeat.Restart();
-            while (true)
-            {
-                token.ThrowIfCancellationRequested();
-                string message = null;
-                try
-                {
-                    message = await _brokerServer.GetMessageAsync(_session, _settings, null/*_lastMessageId*/, token);
-                    _term.WriteLine($"{DateTime.UtcNow:u}: {message}");
-                    if (!string.IsNullOrEmpty(message))
-                    {
-                        var messageRef = StringUtil.ConvertFromJson<MessageRef>(message);
-                        var client = new HttpClient();
-                        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", messageRef.Token);
-                        var response = await client.GetAsync(messageRef.Url, token);
-                        if (!response.IsSuccessStatusCode)
-                        {
-                            var content = default(string);
-                            try
-                            {
-                                content = await response.Content.ReadAsStringAsync();
-                            }
-                            catch
-                            {
-                            }
-
-                            var error = $"HTTP {(int)response.StatusCode} {Enum.GetName(typeof(HttpStatusCode), response.StatusCode)}";
-                            if (!string.IsNullOrEmpty(content))
-                            {
-                                error = $"{error}: {content}";
-                            }
-                            throw new Exception(error);
-                        }
-
-                        var fullMessage = await response.Content.ReadAsStringAsync();
-                        return StringUtil.ConvertFromJson<TaskAgentMessage>(fullMessage);
-                    }
-
-                    if (encounteringError) //print the message once only if there was an error
-                    {
-                        _term.WriteLine($"{DateTime.UtcNow:u}: Runner reconnected.");
-                        encounteringError = false;
-                        continuousError = 0;
-                    }
-                }
-                catch (OperationCanceledException) when (token.IsCancellationRequested)
-                {
-                    Trace.Info("Get next message has been cancelled.");
-                    throw;
-                }
-                catch (TaskAgentAccessTokenExpiredException)
-                {
-                    Trace.Info("Runner OAuth token has been revoked. Unable to pull message.");
-                    _accessTokenRevoked = true;
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    Trace.Error("Catch exception during get next message.");
-                    Trace.Error(ex);
-
-                    // don't retry if SkipSessionRecover = true, DT service will delete agent session to stop agent from taking more jobs.
-                    if (ex is TaskAgentSessionExpiredException && !_settings.SkipSessionRecover && await CreateSessionAsync(token))
-                    {
-                        Trace.Info($"{nameof(TaskAgentSessionExpiredException)} received, recovered by recreate session.");
-                    }
-                    else if (!IsGetNextMessageExceptionRetriable(ex))
-                    {
-                        throw;
-                    }
-                    else
-                    {
-                        continuousError++;
-                        //retry after a random backoff to avoid service throttling
-                        //in case of there is a service error happened and all agents get kicked off of the long poll and all agent try to reconnect back at the same time.
-                        if (continuousError <= 5)
-                        {
-                            // random backoff [15, 30]
-                            _getNextMessageRetryInterval = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(30), _getNextMessageRetryInterval);
-                        }
-                        else
-                        {
-                            // more aggressive backoff [30, 60]
-                            _getNextMessageRetryInterval = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(60), _getNextMessageRetryInterval);
-                        }
-
-                        if (!encounteringError)
-                        {
-                            //print error only on the first consecutive error
-                            _term.WriteError($"{DateTime.UtcNow:u}: Runner connect error: {ex.Message}. Retrying until reconnected.");
-                            encounteringError = true;
-                        }
-
-                        // re-create VssConnection before next retry
-                        await _runnerServer.RefreshConnectionAsync(RunnerConnectionType.MessageQueue, TimeSpan.FromSeconds(60));
-
-                        Trace.Info("Sleeping for {0} seconds before retrying.", _getNextMessageRetryInterval.TotalSeconds);
-                        await HostContext.Delay(_getNextMessageRetryInterval, token);
-                    }
-                }
-
-                // if (message == null)
-                // {
-                //     if (heartbeat.Elapsed > TimeSpan.FromMinutes(30))
-                //     {
-                //         Trace.Info($"No message retrieved from session '{_session.SessionId}' within last 30 minutes.");
-                //         heartbeat.Restart();
-                //     }
-                //     else
-                //     {
-                //         Trace.Verbose($"No message retrieved from session '{_session.SessionId}'.");
-                //     }
-
-                //     continue;
-                // }
-
-                // Trace.Info($"Message '{message.MessageId}' received from session '{_session.SessionId}'.");
-                // return message;
-            }
-        }
-#else
         public async Task<TaskAgentMessage> GetNextMessageAsync(CancellationToken token)
         {
             Trace.Entering();
@@ -487,7 +281,6 @@ namespace GitHub.Runner.Listener
                 return message;
             }
         }
-#endif
 
         public async Task DeleteMessageAsync(TaskAgentMessage message)
         {

src/Runner.Listener/Program.cs

@@ -95,7 +95,15 @@ namespace GitHub.Runner.Listener
                 var unknownCommandlines = command.Validate();
                 if (unknownCommandlines.Count > 0)
                 {
-                    terminal.WriteError($"Unrecognized command-line input arguments: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
+                    string commandName = command.GetCommandName();
+                    if (string.IsNullOrEmpty(commandName))
+                    {
+                        terminal.WriteError($"This command does not recognize the command-line input arguments: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
+                    }
+                    else
+                    {
+                        terminal.WriteError($"Unrecognized command-line input arguments for command {commandName}: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
+                    }
                 }
 
                 // Defer to the Runner class to execute the command.

src/Runner.Listener/Runner.cs

@@ -13,10 +13,6 @@ using GitHub.Runner.Sdk;
 using System.Linq;
 using GitHub.Runner.Listener.Check;
 using System.Collections.Generic;
-using System.Runtime.Serialization;
-using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
 
 namespace GitHub.Runner.Listener
 {
@@ -453,37 +449,7 @@ namespace GitHub.Runner.Listener
                                 {
                                     Trace.Info($"Received job message of length {message.Body.Length} from service, with hash '{IOUtil.GetSha256Hash(message.Body)}'");
                                     var jobMessage = StringUtil.ConvertFromJson<Pipelines.AgentJobRequestMessage>(message.Body);
-                                    jobDispatcher.Run(Guid.Empty, jobMessage, runOnce);
-                                    if (runOnce)
-                                    {
-                                        Trace.Info("One time used runner received job message.");
-                                        runOnceJobReceived = true;
-                                    }
-                                }
-                            }
-                            // Broker flow
-                            else if (string.Equals(message.MessageType, JobRequestMessageTypes.RunnerJobRequest, StringComparison.OrdinalIgnoreCase))
-                            {
-                                if (autoUpdateInProgress || runOnceJobReceived)
-                                {
-                                    skipMessageDeletion = true;
-                                    Trace.Info($"Skip message deletion for job request message '{message.MessageId}'.");
-                                }
-                                else
-                                {
-                                    var messageRef = StringUtil.ConvertFromJson<MessageRef>(message.Body);
-
-                                    // Create connection
-                                    var credMgr = HostContext.GetService<ICredentialManager>();
-                                    var creds = credMgr.LoadCredentials();
-
-                                    // todo: add retries
-                                    var runServer = HostContext.CreateService<IRunServer>();
-                                    await runServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
-                                    var jobMessage = await runServer.GetJobMessageAsync(messageRef.ScopeId, messageRef.HostId, messageRef.PlanType, messageRef.PlanGroup, messageRef.PlanId, messageRef.InstanceRefs);
-
-                                    // todo: Trace.Info($"Received job message of length {message.Body.Length} from service, with hash '{IOUtil.GetSha256Hash(message.Body)}'");
-                                    jobDispatcher.Run(messageRef.HostId, jobMessage, runOnce);
+                                    jobDispatcher.Run(jobMessage, runOnce);
                                     if (runOnce)
                                     {
                                         Trace.Info("One time used runner received job message.");

src/Runner.Sdk/Util/VssUtil.cs

@@ -36,7 +36,6 @@ namespace GitHub.Runner.Sdk
 
         public static VssConnection CreateConnection(Uri serverUri, VssCredentials credentials, IEnumerable<DelegatingHandler> additionalDelegatingHandler = null, TimeSpan? timeout = null)
         {
-            // System.Console.WriteLine("VssUtil.CreateConnection");
             VssClientHttpRequestSettings settings = VssClientHttpRequestSettings.Default.Clone();
 
             int maxRetryRequest;

src/Runner.Worker/ActionManager.cs

@@ -817,7 +817,6 @@ namespace GitHub.Runner.Worker
                                     {
                                         // Something else bad happened, let's go to our retry logic
                                         response.EnsureSuccessStatusCode();
-                                        throw new Exception("Unexpected response code: " + response.StatusCode);
                                     }
                                 }
                             }
@@ -1005,7 +1004,7 @@ namespace GitHub.Runner.Worker
                 if (actionDefinitionData.Execution.ExecutionType == ActionExecutionType.Container)
                 {
                     var containerAction = actionDefinitionData.Execution as ContainerActionExecutionData;
-                    if (containerAction.Image.EndsWith("Dockerfile") || containerAction.Image.EndsWith("dockerfile"))
+                    if (DockerUtil.IsDockerfile(containerAction.Image))
                     {
                         var dockerFileFullPath = Path.Combine(actionEntryDirectory, containerAction.Image);
                         executionContext.Debug($"Dockerfile for action: '{dockerFileFullPath}'.");

src/Runner.Worker/ActionRunner.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.ObjectTemplating;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
@@ -9,7 +10,6 @@ using GitHub.DistributedTask.Pipelines.ObjectTemplating;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
-using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Handlers;
 using Pipelines = GitHub.DistributedTask.Pipelines;
 
@@ -171,8 +171,16 @@ namespace GitHub.Runner.Worker
 
             // Load the inputs.
             ExecutionContext.Debug("Loading inputs");
-            var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
-            var inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, ExecutionContext.ExpressionValues, ExecutionContext.ExpressionFunctions);
+            Dictionary<string, string> inputs;
+            if (ExecutionContext.Global.Variables.GetBoolean(Constants.Runner.Features.UseContainerPathForTemplate) ?? false)
+            {
+                inputs = EvaluateStepInputs(stepHost);
+            }
+            else
+            {
+                var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
+                inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, ExecutionContext.ExpressionValues, ExecutionContext.ExpressionFunctions);
+            }
 
             var userInputs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             foreach (KeyValuePair<string, string> input in inputs)
@@ -299,6 +307,15 @@ namespace GitHub.Runner.Worker
             return didFullyEvaluate;
         }
 
+        private Dictionary<String, String> EvaluateStepInputs(IStepHost stepHost)
+        {
+            DictionaryContextData expressionValues = ExecutionContext.GetExpressionValues(stepHost);
+            var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
+            var inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, expressionValues, ExecutionContext.ExpressionFunctions);
+
+            return inputs;
+        }
+
         private string GenerateDisplayName(ActionStep action, DictionaryContextData contextData, IExecutionContext context, out bool didFullyEvaluate)
         {
             ArgUtil.NotNull(context, nameof(context));

src/Runner.Worker/Container/DockerUtil.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
 
 namespace GitHub.Runner.Worker.Container
@@ -17,7 +18,7 @@ namespace GitHub.Runner.Worker.Container
             string pattern = $"^(?<{targetPort}>\\d+)/(?<{proto}>\\w+) -> (?<{host}>.+):(?<{hostPort}>\\d+)$";
 
             List<PortMapping> portMappings = new List<PortMapping>();
-            foreach(var line in portMappingLines)
+            foreach (var line in portMappingLines)
             {
                 Match m = Regex.Match(line, pattern, RegexOptions.None, TimeSpan.FromSeconds(1));
                 if (m.Success)
@@ -61,5 +62,15 @@ namespace GitHub.Runner.Worker.Container
             }
             return "";
         }
+
+        public static bool IsDockerfile(string image)
+        {
+            if (image.StartsWith("docker://", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+            var imageWithoutPath = image.Split('/').Last();
+            return imageWithoutPath.StartsWith("Dockerfile.") || imageWithoutPath.StartsWith("dockerfile.") || imageWithoutPath.EndsWith("Dockerfile") || imageWithoutPath.EndsWith("dockerfile");
+        }
     }
 }

src/Runner.Worker/ExecutionContext.cs

@@ -1,18 +1,13 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Web;
 using GitHub.DistributedTask.Expressions2;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
-using GitHub.DistributedTask.Pipelines;
 using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.Pipelines.ObjectTemplating;
 using GitHub.DistributedTask.WebApi;
@@ -20,7 +15,7 @@ using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker.Container;
-using GitHub.Services.WebApi;
+using GitHub.Runner.Worker.Handlers;
 using Newtonsoft.Json;
 using ObjectTemplating = GitHub.DistributedTask.ObjectTemplating;
 using Pipelines = GitHub.DistributedTask.Pipelines;
@@ -115,7 +110,6 @@ namespace GitHub.Runner.Worker
         void UpdateGlobalStepsContext();
 
         void WriteWebhookPayload();
-
     }
 
     public sealed class ExecutionContext : RunnerService, IExecutionContext
@@ -1199,6 +1193,66 @@ namespace GitHub.Runner.Worker
         {
             return new TemplateTraceWriter(context);
         }
+
+        public static DictionaryContextData GetExpressionValues(this IExecutionContext context, IStepHost stepHost)
+        {
+            if (stepHost is ContainerStepHost)
+            {
+
+                var expressionValues = context.ExpressionValues.Clone() as DictionaryContextData;
+                context.UpdatePathsInExpressionValues("github", expressionValues, stepHost);
+                context.UpdatePathsInExpressionValues("runner", expressionValues, stepHost);
+                return expressionValues;
+            }
+            else
+            {
+                return context.ExpressionValues.Clone() as DictionaryContextData;
+            }
+        }
+
+        private static void UpdatePathsInExpressionValues(this IExecutionContext context, string contextName, DictionaryContextData expressionValues, IStepHost stepHost)
+        {
+            var dict = expressionValues[contextName].AssertDictionary($"expected context {contextName} to be a dictionary");
+            context.ResolvePathsInExpressionValuesDictionary(dict, stepHost);
+            expressionValues[contextName] = dict;
+        }
+
+        private static void ResolvePathsInExpressionValuesDictionary(this IExecutionContext context, DictionaryContextData dict, IStepHost stepHost)
+        {
+            foreach (var key in dict.Keys.ToList())
+            {
+                if (dict[key] is StringContextData)
+                {
+                    var value = dict[key].ToString();
+                    if (!string.IsNullOrEmpty(value))
+                    {
+                        dict[key] = new StringContextData(stepHost.ResolvePathForStepHost(value));
+                    }
+                }
+                else if (dict[key] is DictionaryContextData)
+                {
+                    var innerDict = dict[key].AssertDictionary("expected dictionary");
+                    context.ResolvePathsInExpressionValuesDictionary(innerDict, stepHost);
+                    var updatedDict = new DictionaryContextData();
+                    foreach (var k in innerDict.Keys.ToList())
+                    {
+                        updatedDict[k] = innerDict[k];
+                    }
+                    dict[key] = updatedDict;
+                }
+                else if (dict[key] is CaseSensitiveDictionaryContextData)
+                {
+                    var innerDict = dict[key].AssertDictionary("expected dictionary");
+                    context.ResolvePathsInExpressionValuesDictionary(innerDict, stepHost);
+                    var updatedDict = new CaseSensitiveDictionaryContextData();
+                    foreach (var k in innerDict.Keys.ToList())
+                    {
+                        updatedDict[k] = innerDict[k];
+                    }
+                    dict[key] = updatedDict;
+                }
+            }
+        }
     }
 
     internal sealed class TemplateTraceWriter : ObjectTemplating.ITraceWriter

src/Runner.Worker/FileCommandManager.cs

@@ -15,7 +15,7 @@ namespace GitHub.Runner.Worker
     {
         void InitializeFiles(IExecutionContext context, ContainerInfo container);
         void ProcessFiles(IExecutionContext context, ContainerInfo container);
-    
+
     }
 
     public sealed class FileCommandManager : RunnerService, IFileCommandManager
@@ -57,7 +57,7 @@ namespace GitHub.Runner.Worker
                 TryDeleteFile(newPath);
                 File.Create(newPath).Dispose();
 
-                var pathToSet = container != null ? container.TranslateToContainerPath(newPath) : newPath; 
+                var pathToSet = container != null ? container.TranslateToContainerPath(newPath) : newPath;
                 context.SetGitHubContext(fileCommand.ContextName, pathToSet);
             }
         }
@@ -66,7 +66,7 @@ namespace GitHub.Runner.Worker
         {
             foreach (var fileCommand in _commandExtensions)
             {
-                try 
+                try
                 {
                     fileCommand.ProcessCommand(context, Path.Combine(_fileCommandDirectory, fileCommand.FilePrefix + _fileSuffix),container);
                 }
@@ -266,7 +266,7 @@ namespace GitHub.Runner.Worker
 
     public sealed class CreateStepSummaryCommand : RunnerService, IFileCommandExtension
     {
-        private const int _attachmentSizeLimit = 128 * 1024;
+        public const int AttachmentSizeLimit = 1024 * 1024;
 
         public string ContextName => "step_summary";
         public string FilePrefix => "step_summary_";
@@ -296,9 +296,9 @@ namespace GitHub.Runner.Worker
                     return;
                 }
 
-                if (fileSize > _attachmentSizeLimit)
+                if (fileSize > AttachmentSizeLimit)
                 {
-                    context.Error(String.Format(Constants.Runner.UnsupportedSummarySize, _attachmentSizeLimit / 1024, fileSize / 1024));
+                    context.Error(String.Format(Constants.Runner.UnsupportedSummarySize, AttachmentSizeLimit / 1024, fileSize / 1024));
                     Trace.Info($"Step Summary file ({filePath}) is too large ({fileSize} bytes); skipping attachment upload");
 
                     return;

src/Runner.Worker/Handlers/ContainerActionHandler.cs

@@ -44,9 +44,8 @@ namespace GitHub.Runner.Worker.Handlers
             {
                 Data.Image = Data.Image.Substring("docker://".Length);
             }
-            else if (Data.Image.EndsWith("Dockerfile") || Data.Image.EndsWith("dockerfile"))
+            else if (DockerUtil.IsDockerfile(Data.Image))
             {
-                // ensure docker file exist
                 var dockerFile = Path.Combine(ActionDirectory, Data.Image);
                 ArgUtil.File(dockerFile, nameof(Data.Image));
 
@@ -68,6 +67,10 @@ namespace GitHub.Runner.Worker.Handlers
 
                 Data.Image = imageName;
             }
+            else
+            {
+                throw new InvalidOperationException($"'{Data.Image}' should be either '[path]/Dockerfile' or 'docker://image[:tag]'.");
+            }
 
             string type = Action.Type == Pipelines.ActionSourceType.Repository ? "Dockerfile" : "DockerHub";
             // Set extra telemetry base on the current context.

src/Runner.Worker/Handlers/OutputManager.cs

@@ -151,6 +151,11 @@ namespace GitHub.Runner.Worker.Handlers
                 }
             }
 
+            if (line.Contains("fatal: unsafe repository", StringComparison.OrdinalIgnoreCase))
+            {
+                _executionContext.StepTelemetry.ErrorMessages.Add(line);
+            }
+
             // Regular output
             _executionContext.Output(line);
         }

src/Runner.Worker/Handlers/StepHost.cs

@@ -1,18 +1,13 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Text;
 using System.Threading;
-using System.Threading.Channels;
 using System.Threading.Tasks;
-using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Common.Util;
 using GitHub.Runner.Worker.Container;
-using GitHub.Services.WebApi;
-using Newtonsoft.Json;
 using GitHub.Runner.Common;
 using GitHub.Runner.Sdk;
 using System.Linq;
+using GitHub.DistributedTask.Pipelines.ContextData;
 
 namespace GitHub.Runner.Worker.Handlers
 {

src/Runner.Worker/action_yaml.json

@@ -132,7 +132,7 @@
                     "continue-on-error": "boolean-steps-context",
                     "working-directory": "string-steps-context",
                     "shell": {
-                        "type": "non-empty-string",
+                        "type": "string-steps-context",
                         "required": true
                     }
                 }

src/Sdk/Common/Common/Authentication/FederatedCredential.cs

@@ -18,7 +18,6 @@ namespace GitHub.Services.Common
 
         public override bool IsAuthenticationChallenge(IHttpResponse webResponse)
         {
-            // System.Console.WriteLine($"FederatedCredential.IsAuthenticationChallenge");
             if (webResponse == null)
             {
                 return false;

src/Sdk/Common/Common/Authentication/IssuedTokenCredential.cs

@@ -88,7 +88,6 @@ namespace GitHub.Services.Common
             IHttpResponse response,
             IssuedToken failedToken)
         {
-            // System.Console.WriteLine("IssuedTokenCredential.CreateTokenProvider");
             if (response != null && !IsAuthenticationChallenge(response))
             {
                 throw new InvalidOperationException();
@@ -100,14 +99,12 @@ namespace GitHub.Services.Common
                 {
                     throw new InvalidOperationException($"The {nameof(TokenStorageUrl)} property must have a value if the {nameof(Storage)} property is set on this instance of {GetType().Name}.");
                 }
-                // System.Console.WriteLine($"IssuedTokenCredential.CreateTokenProvider: TokenStorageUrl: {TokenStorageUrl}");
                 InitialToken = Storage.RetrieveToken(TokenStorageUrl, CredentialType);
             }
 
             IssuedTokenProvider provider = OnCreateTokenProvider(serverUrl, response);
             if (provider != null)
             {
-                // System.Console.WriteLine($"IssuedTokenCredential.CreateTokenProvider: provider: {provider}");
                 provider.TokenStorageUrl = TokenStorageUrl;
             }
 
@@ -126,7 +123,6 @@ namespace GitHub.Services.Common
 
         internal virtual string GetAuthenticationChallenge(IHttpResponse webResponse)
         {
-            // System.Console.WriteLine($"IssuedTokenCredential.GetAuthenticationChallenge");
             IEnumerable<String> values;
             if (!webResponse.Headers.TryGetValues(Internal.HttpHeaders.WwwAuthenticate, out values))
             {

src/Sdk/Common/Common/Authentication/VssCredentials.cs

@@ -108,7 +108,6 @@ namespace GitHub.Services.Common
             TaskScheduler scheduler,
             IVssCredentialPrompt credentialPrompt)
         {
-            // System.Console.WriteLine($"VssCredentials.ctor");
             this.PromptType = promptType;
 
             if (promptType == CredentialPromptType.PromptIfNeeded && scheduler == null)
@@ -151,7 +150,6 @@ namespace GitHub.Services.Common
         {
             get
             {
-                // System.Console.WriteLine($"VssCredentials.get_PromptType");
                 return m_promptType;
             }
             set
@@ -172,7 +170,6 @@ namespace GitHub.Services.Common
         {
             get
             {
-                // System.Console.WriteLine($"VssCredentials.get_Federated");
                 return m_federatedCredential;
             }
         }
@@ -187,7 +184,6 @@ namespace GitHub.Services.Common
         {
             get
             {
-                // System.Console.WriteLine($"VssCredentials.get_Storage");
                 return m_credentialStorage;
             }
             set
@@ -207,7 +203,6 @@ namespace GitHub.Services.Common
         /// </summary>
         internal virtual bool TryGetValidAdalToken(IVssCredentialPrompt prompt)
         {
-            // System.Console.WriteLine($"VssCredentials.TryGetValidAdalToken");
             return false;
         }
 
@@ -223,7 +218,6 @@ namespace GitHub.Services.Common
             IHttpResponse webResponse,
             IssuedToken failedToken)
         {
-            // System.Console.WriteLine("VssCredential.CreateTokenProvider");
             ArgumentUtility.CheckForNull(serverUrl, "serverUrl");
 
             IssuedTokenProvider tokenProvider = null;
@@ -269,7 +263,6 @@ namespace GitHub.Services.Common
             Uri serverUrl,
             out IssuedTokenProvider provider)
         {
-            // System.Console.WriteLine($"VssCredentials.TryGetTokenProvider");
             ArgumentUtility.CheckForNull(serverUrl, "serverUrl");
 
             lock (m_thisLock)
@@ -279,13 +272,11 @@ namespace GitHub.Services.Common
                 {
                     if (m_federatedCredential != null)
                     {
-                        // System.Console.WriteLine($"VssCredentials.TryGetTokenProvider: Using federated credential");
                         m_currentProvider = m_federatedCredential.CreateTokenProvider(serverUrl, null, null);
                     }
 
                     if (m_currentProvider != null)
                     {
-                        // System.Console.WriteLine($"VssCredentials.TryGetTokenProvider: Issued token provider created");
                         VssHttpEventSource.Log.IssuedTokenProviderCreated(VssTraceActivity.Current, m_currentProvider);
                     }
                 }
@@ -303,7 +294,6 @@ namespace GitHub.Services.Common
         /// <returns>True if this is an token authentication redirect, false otherwise</returns>
         internal bool IsAuthenticationChallenge(IHttpResponse webResponse)
         {
-            // System.Console.WriteLine($"VssCredentials.IsAuthenticationChallenge");
             if (webResponse == null)
             {
                 return false;
@@ -323,7 +313,6 @@ namespace GitHub.Services.Common
             Uri serviceLocation,
             string identityProvider)
         {
-            // System.Console.WriteLine($"VssCredentials.SignOut");
             // Remove the token in the storage and the current token provider. Note that we don't
             // call InvalidateToken here because we want to remove the whole token not just its value
             if ((m_currentProvider != null) && (m_currentProvider.CurrentToken != null))
@@ -360,7 +349,6 @@ namespace GitHub.Services.Common
             string token,
             IDictionary<string, string> attributes)
         {
-            // System.Console.WriteLine($"VssCredentials.WriteAuthorizationToken");
             int i = 0;
             for (int j = 0; j < token.Length; i++, j += 128)
             {
@@ -372,7 +360,6 @@ namespace GitHub.Services.Common
 
         protected static string ReadAuthorizationToken(IDictionary<string, string> attributes)
         {
-            // System.Console.WriteLine($"VssCredentials.ReadAuthorizationToken");
             string authTokenCountValue;
             if (attributes.TryGetValue("AuthTokenSegmentCount", out authTokenCountValue))
             {

src/Sdk/Common/Common/ClientStorage/VssFileStorage.cs

@@ -23,7 +23,6 @@ namespace GitHub.Services.Common.ClientStorage
         private readonly string m_filePath;
         private readonly VssFileStorageReader m_reader;
         private readonly IVssClientStorageWriter m_writer;
-
         private const char c_defaultPathSeparator = '\\';
         private const bool c_defaultIgnoreCaseInPaths = false;
 
@@ -192,7 +191,7 @@ namespace GitHub.Services.Common.ClientStorage
                 // Windows Impersonation is being used.
 
                 // Check to see if we can find the user's local application data directory.
-                string subDir = "GitHub\\ActionsService";
+                string subDir = Path.Combine("GitHub", "ActionsService");
                 string path = Environment.GetEnvironmentVariable("localappdata");
                 SafeGetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                 if (string.IsNullOrEmpty(path))

src/Sdk/Common/Common/VssHttpMessageHandler.cs

@@ -49,7 +49,6 @@ namespace GitHub.Services.Common
             VssHttpRequestSettings settings,
             HttpMessageHandler innerHandler)
         {
-            // System.Console.WriteLine("VssHttpMessageHandler.ctor");
             this.Credentials = credentials;
             this.Settings = settings;
             this.ExpectContinue = settings.ExpectContinue;
@@ -123,7 +122,6 @@ namespace GitHub.Services.Common
             HttpRequestMessage request,
             CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("VssHttpMessageHandler.SendAsync");
             VssTraceActivity traceActivity = VssTraceActivity.Current;
 
             var traceInfo = VssHttpMessageHandlerTraceInfo.GetTraceInfo(request);
@@ -132,7 +130,6 @@ namespace GitHub.Services.Common
             if (!m_appliedClientCertificatesToTransportHandler &&
                 request.RequestUri.Scheme == "https")
             {
-                // System.Console.WriteLine("VssHttpMessageHandler.SendAsync: !appliedClientCertificatesToTransportHandler");
                 HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
                 if (httpClientHandler != null &&
                     this.Settings.ClientCertificateManager != null &&
@@ -147,7 +144,6 @@ namespace GitHub.Services.Common
             if (!m_appliedServerCertificateValidationCallbackToTransportHandler &&
                 request.RequestUri.Scheme == "https")
             {
-                // System.Console.WriteLine("VssHttpMessageHandler.SendAsync: !appliedServerCertificateValidationCallbackToTransportHandler");
                 HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
                 if (httpClientHandler != null &&
                     this.Settings.ServerCertificateValidationCallback != null)
@@ -169,7 +165,6 @@ namespace GitHub.Services.Common
             IssuedTokenProvider provider;
             if (this.Credentials.TryGetTokenProvider(request.RequestUri, out provider))
             {
-                // System.Console.WriteLine("VssHttpMessageHandler.SendAsync: Got token provider from credentials");
                 token = provider.CurrentToken;
             }
 
@@ -230,7 +225,6 @@ namespace GitHub.Services.Common
 
                     traceInfo?.TraceResponseContentTime();
 
-                    // System.Console.WriteLine($"VssHttpMessageHandler.SendAsync: Creating response wrapper");
                     responseWrapper = new HttpResponseMessageWrapper(response);
 
                     if (!this.Credentials.IsAuthenticationChallenge(responseWrapper))
@@ -238,7 +232,6 @@ namespace GitHub.Services.Common
                         // Validate the token after it has been successfully authenticated with the server.
                         if (provider != null)
                         {
-                            // System.Console.WriteLine("VssHttpMessageHandler.SendAsync: Validating token");
                             provider.ValidateToken(token, responseWrapper);
                         }
 
@@ -250,7 +243,6 @@ namespace GitHub.Services.Common
                     }
                     else
                     {
-                        // System.Console.WriteLine($"VssHttpMessageHandler.SendAsync: Auth challenge. Response status code {response.StatusCode}; headers {response.Headers}");
                         // In the case of a Windows token, only apply it to the web proxy if it
                         // returned a 407 Proxy Authentication Required. If we didn't get this
                         // status code back, then the proxy (if there is one) is clearly working fine,
@@ -296,7 +288,6 @@ namespace GitHub.Services.Common
                         }
 
                         // Now invoke the provider and await the result
-                        // System.Console.WriteLine($"VssHttpMessageHandler.SendAsync: Calling GetTokenAsync");
                         token = await provider.GetTokenAsync(token, tokenSource.Token).ConfigureAwait(false);
 
                         // I always see 0 here, but the method above could take more time so keep for now
@@ -441,7 +432,6 @@ namespace GitHub.Services.Common
                     activity != VssTraceActivity.Empty &&
                     !request.Headers.Contains(HttpHeaders.TfsSessionHeader))
                 {
-                    // System.Console.WriteLine($"VssHttpMessageHandler.ApplyHeaders: Activity ID {activity.Id}");
                     request.Headers.Add(HttpHeaders.TfsSessionHeader, activity.Id.ToString("D"));
                 }
 
@@ -462,16 +452,13 @@ namespace GitHub.Services.Common
             ICredentials credentialsToken = token as ICredentials;
             if (credentialsToken != null)
             {
-                // System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Credentials token != null");
                 if (applyICredentialsToWebProxy)
                 {
-                    // System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Apply credentials to web proxy");
                     HttpClientHandler httpClientHandler = m_transportHandler as HttpClientHandler;
 
                     if (httpClientHandler != null &&
                         httpClientHandler.Proxy != null)
                     {
-                        // System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Setting proxy crednetials");
                         httpClientHandler.Proxy.Credentials = credentialsToken;
                     }
                 }
@@ -480,7 +467,6 @@ namespace GitHub.Services.Common
             }
             else
             {
-                // System.Console.WriteLine("VssHttpMessageHandler.ApplyToken: Applying credentials to request");
                 token.ApplyTo(new HttpRequestMessageWrapper(request));
             }
         }
@@ -493,8 +479,7 @@ namespace GitHub.Services.Common
             HttpClientHandler httpClientHandler = handler as HttpClientHandler;
             if (httpClientHandler != null)
             {
-                // System.Console.WriteLine($"VssHttpMessageHandler.ApplySettings: Default credentials = {defaultCredentials} AllowAutoRedirect = {settings.AllowAutoRedirect}");
-                httpClientHandler.AllowAutoRedirect = true; //settings.AllowAutoRedirect;
+                httpClientHandler.AllowAutoRedirect = settings.AllowAutoRedirect;
                 httpClientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
                 //Setting httpClientHandler.UseDefaultCredentials to false in .Net Core, clears httpClientHandler.Credentials if
                 //credentials is already set to defaultcredentials. Therefore httpClientHandler.Credentials must be 
@@ -565,7 +550,6 @@ namespace GitHub.Services.Common
                 Uri uri,
                 String authType)
             {
-                // System.Console.WriteLine($"CredentialWrapper.GetCredential: InnerCredentials = {InnerCredentials}");
                 return InnerCredentials != null ? InnerCredentials.GetCredential(uri, authType) : null;
             }
         }

src/Sdk/DTGenerated/Generated/TaskAgentHttpClientBase.cs

@@ -27,7 +27,6 @@ using System.Net.Http.Headers;
 using System.Net.Http.Formatting;
 using System.Threading;
 using System.Threading.Tasks;
-using GitHub.DistributedTask.Pipelines;
 using GitHub.Services.Common;
 using GitHub.Services.WebApi;
 
@@ -379,7 +378,6 @@ namespace GitHub.DistributedTask.WebApi
         /// <param name="requestId"></param>
         /// <param name="lockToken"></param>
         /// <param name="request"></param>
-        /// <param name="targetHostId"></param>
         /// <param name="userState"></param>
         /// <param name="cancellationToken">The cancellation token to cancel operation.</param>
         [EditorBrowsable(EditorBrowsableState.Never)]
@@ -388,7 +386,6 @@ namespace GitHub.DistributedTask.WebApi
             long requestId,
             Guid lockToken,
             TaskAgentJobRequest request,
-            Guid targetHostId,
             object userState = null,
             CancellationToken cancellationToken = default)
         {
@@ -399,7 +396,6 @@ namespace GitHub.DistributedTask.WebApi
 
             List<KeyValuePair<string, string>> queryParams = new List<KeyValuePair<string, string>>();
             queryParams.Add("lockToken", lockToken.ToString());
-            queryParams.Add("targetHostId", targetHostId.ToString());
 
             return SendAsync<TaskAgentJobRequest>(
                 httpMethod,
@@ -707,47 +703,6 @@ namespace GitHub.DistributedTask.WebApi
                 cancellationToken: cancellationToken);
         }
 
-        /// <summary>
-        /// [Preview API]
-        /// </summary>
-        /// <param name="scopeId"></param>
-        /// <param name="planType"></param>
-        /// <param name="planGroup"></param>
-        /// <param name="planId"></param>
-        /// <param name="instanceRefsJson"></param>
-        /// <param name="userState"></param>
-        /// <param name="cancellationToken">The cancellation token to cancel operation.</param>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public virtual Task<Pipelines.AgentJobRequestMessage> GetJobMessageAsync(
-            Guid scopeId,
-            Guid hostId,
-            string planType,
-            string planGroup,
-            Guid planId,
-            string instanceRefsJson,
-            object userState = null,
-            CancellationToken cancellationToken = default)
-        {
-            HttpMethod httpMethod = new HttpMethod("GET");
-            Guid locationId = new Guid("25adab70-1379-4186-be8e-b643061ebe3a");
-
-            List<KeyValuePair<string, string>> queryParams = new List<KeyValuePair<string, string>>();
-            queryParams.Add("scopeId", scopeId.ToString());
-            queryParams.Add("hostId", hostId.ToString());
-            queryParams.Add("planType", planType);
-            queryParams.Add("planGroup", planGroup);
-            queryParams.Add("planId", planId.ToString());
-            queryParams.Add("instanceRefsJson", instanceRefsJson);
-
-            return SendAsync<Pipelines.AgentJobRequestMessage>(
-                httpMethod,
-                locationId,
-                version: new ApiResourceVersion(6.0, 1),
-                queryParameters: queryParams,
-                userState: userState,
-                cancellationToken: cancellationToken);
-        }
-
         /// <summary>
         /// [Preview API]
         /// </summary>
@@ -762,7 +717,6 @@ namespace GitHub.DistributedTask.WebApi
             object userState = null,
             CancellationToken cancellationToken = default)
         {
-            // System.Console.WriteLine("TaskAgentHttpClientBase.CreateAgentSessionAsync");
             HttpMethod httpMethod = new HttpMethod("POST");
             Guid locationId = new Guid("134e239e-2df3-4794-a6f6-24f1f19ec8dc");
             object routeValues = new { poolId = poolId };

src/Sdk/DTWebApi/WebApi/JobRequestMessageTypes.cs

@@ -5,6 +5,5 @@ namespace GitHub.DistributedTask.WebApi
     public static class JobRequestMessageTypes
     {
         public const String PipelineAgentJobRequest = "PipelineAgentJobRequest";
-        public const String RunnerJobRequest = "RunnerJobRequest";
     }
 }

src/Sdk/DTWebApi/WebApi/TaskAgentHttpClient.cs

@@ -64,7 +64,6 @@ namespace GitHub.DistributedTask.WebApi
             Guid lockToken,
             DateTime finishTime,
             TaskResult result,
-            Guid targetHostId,
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
@@ -75,7 +74,7 @@ namespace GitHub.DistributedTask.WebApi
                 Result = result,
             };
 
-            return UpdateAgentRequestAsync(poolId, requestId, lockToken, request, targetHostId, userState, cancellationToken);
+            return UpdateAgentRequestAsync(poolId, requestId, lockToken, request, userState, cancellationToken);
         }
 
         public Task<List<TaskAgent>> GetAgentsAsync(
@@ -153,7 +152,6 @@ namespace GitHub.DistributedTask.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             Func<HttpResponseMessage, CancellationToken, Task<T>> processResponse = null)
         {
-            // System.Console.WriteLine("TaskAgentHttpClient.SendAsync 1");
             return SendAsync<T>(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken, processResponse);
         }
 
@@ -172,7 +170,6 @@ namespace GitHub.DistributedTask.WebApi
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
-                // System.Console.WriteLine("TaskAgentHttpClient.SendAsync 2");
                 return await SendAsync<T>(requestMessage, userState, cancellationToken, processResponse).ConfigureAwait(false);
             }
         }
@@ -183,7 +180,6 @@ namespace GitHub.DistributedTask.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             Func<HttpResponseMessage, CancellationToken, Task<T>> processResponse = null)
         {
-            // System.Console.WriteLine("TaskAgentHttpClient.SendAsync 3");
             if (processResponse == null)
             {
                 processResponse = ReadContentAsAsync<T>;

src/Sdk/WebApi/WebApi/Location/ServerDataProvider.cs

@@ -801,7 +801,6 @@ namespace GitHub.Services.WebApi.Location
 
         private async Task<ConnectionData> GetConnectionDataAsync(ConnectOptions connectOptions, int lastChangeId, CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine("ServerDataProvider.GetConnectionDataAsync");
             int timeoutRetries = 1;
 
             while (true)

src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessToken.cs

@@ -75,7 +75,6 @@ namespace GitHub.Services.OAuth
 
         internal override void ApplyTo(IHttpRequest request)
         {
-            // System.Console.WriteLine($"VssOAuthAccessToken.ApplyTo: Bearer {m_value}");
             request.Headers.SetValue(Common.Internal.HttpHeaders.Authorization, $"Bearer {m_value}");
         }
 

src/Sdk/WebApi/WebApi/OAuth/VssOAuthAccessTokenCredential.cs

@@ -60,7 +60,6 @@ namespace GitHub.Services.OAuth
             Uri serverUrl,
             IHttpResponse response)
         {
-            // System.Console.WriteLine($"VssOAuthAccessTokenCredential.OnCreateTokenProvider");
             return new VssOAuthAccessTokenProvider(this, serverUrl, null);
         }
 
@@ -72,7 +71,6 @@ namespace GitHub.Services.OAuth
                 Uri signInUrl) 
                 : base(credential, serverUrl, signInUrl)
             { 
-                // System.Console.WriteLine($"VssOAuthAccessTokenProvider.ctor");
             }
 
             public override Boolean GetTokenIsInteractive

src/Sdk/WebApi/WebApi/OAuth/VssOAuthCredential.cs

@@ -103,23 +103,17 @@ namespace GitHub.Services.OAuth
         /// <returns>True if the web response indicates an authorization challenge; otherwise, false</returns>
         public override Boolean IsAuthenticationChallenge(IHttpResponse webResponse)
         {
-            // System.Console.WriteLine($"VssOAuthCredential.IsAuthenticationChallenge");
             if (webResponse == null)
             {
-                // System.Console.WriteLine($"VssOAuthCredential.IsAuthenticationChallenge: webResponse is null");
                 return false;
             }
 
             if (webResponse.StatusCode == HttpStatusCode.Found ||
                 webResponse.StatusCode == HttpStatusCode.Unauthorized)
             {
-                // System.Console.WriteLine($"VssOAuthCredential.IsAuthenticationChallenge: found or unauthorized");
-                var result = webResponse.Headers.GetValues(Common.Internal.HttpHeaders.WwwAuthenticate).Any(x => x.IndexOf("Bearer", StringComparison.OrdinalIgnoreCase) >= 0);
-                // System.Console.WriteLine($"VssOAuthCredential.IsAuthenticationChallenge: {result}");
-                return result;
+                return webResponse.Headers.GetValues(Common.Internal.HttpHeaders.WwwAuthenticate).Any(x => x.IndexOf("Bearer", StringComparison.OrdinalIgnoreCase) >= 0);
             }
 
-            // System.Console.WriteLine($"VssOAuthCredential.IsAuthenticationChallenge: false");
             return false;
         }
 
@@ -127,7 +121,6 @@ namespace GitHub.Services.OAuth
             Uri serverUrl, 
             IHttpResponse response)
         {
-            // System.Console.WriteLine($"VssOAuthCredential.OnCreateTokenProvider");
             return new VssOAuthTokenProvider(this, serverUrl);
         }
 

src/Sdk/WebApi/WebApi/OAuth/VssOAuthTokenHttpClient.cs

@@ -54,7 +54,6 @@ namespace GitHub.Services.OAuth
             VssOAuthTokenParameters tokenParameters = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // todo: qqq
             VssTraceActivity traceActivity = VssTraceActivity.Current;
             using (HttpClient client = new HttpClient(CreateMessageHandler(this.AuthorizationUrl)))
             {

src/Sdk/WebApi/WebApi/OAuth/VssOAuthTokenProvider.cs

@@ -47,7 +47,6 @@ namespace GitHub.Services.OAuth
             VssOAuthTokenParameters tokenParameters)
             : base(credential, serverUrl, authorizationUrl)
         {
-            // System.Console.WriteLine($"VssOAuthTokenProvider.ctor");
             m_grant = grant;
             m_tokenParameters = tokenParameters;
             m_clientCredential = clientCrential;
@@ -60,7 +59,6 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_Grant");
                 return m_grant;
             }
         }
@@ -72,7 +70,6 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_ClientCredential");
                 return m_clientCredential;
             }
         }
@@ -84,7 +81,6 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_TokenParameters");
                 return m_tokenParameters;
             }
         }
@@ -96,7 +92,6 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_GetTokenIsInteractive");
                 return false;
             }
         }
@@ -105,7 +100,6 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_AuthenticationParameter");
                 if (this.ClientCredential == null)
                 {
                     return null;
@@ -121,14 +115,12 @@ namespace GitHub.Services.OAuth
         {
             get
             {
-                // System.Console.WriteLine($"VssOAuthTokenProvider.get_AuthenticationScheme");
                 return "Bearer";
             }
         }
 
         public async Task<string> ValidateCredentialAsync(CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine($"VssOAuthTokenProvider.ValidateCredentialAsync: Calling VssOAuthTokenHttpClient.GetTokenAsync");
             var tokenHttpClient = new VssOAuthTokenHttpClient(this.SignInUrl);
             var tokenResponse = await tokenHttpClient.GetTokenAsync(this.Grant, this.ClientCredential, this.TokenParameters, cancellationToken);
 
@@ -147,7 +139,6 @@ namespace GitHub.Services.OAuth
             IssuedToken failedToken,
             CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine($"VssOAuthTokenProvider.OnGetTokenAsync");
             if (this.SignInUrl == null ||
                 this.Grant == null ||
                 this.ClientCredential == null)
@@ -160,7 +151,6 @@ namespace GitHub.Services.OAuth
             try
             {
                 var tokenHttpClient = new VssOAuthTokenHttpClient(this.SignInUrl);
-                // System.Console.WriteLine($"VssOAuthTokenProvider.OnGetTokenAsync: Calling VssOAuthTokenHttpClient.GetTokenAsync; sign-in url {this.SignInUrl.AbsoluteUri}");
                 var tokenResponse = await tokenHttpClient.GetTokenAsync(this.Grant, this.ClientCredential, this.TokenParameters, cancellationToken).ConfigureAwait(false);
                 if (!String.IsNullOrEmpty(tokenResponse.AccessToken))
                 {
@@ -207,7 +197,6 @@ namespace GitHub.Services.OAuth
 
         protected virtual IssuedToken CreateIssuedToken(VssOAuthTokenResponse tokenResponse)
         {
-            // System.Console.WriteLine($"VssOAuthTokenProvider.CreateIssuedToken");
             if (tokenResponse.ExpiresIn > 0)
             {
                 return new VssOAuthAccessToken(tokenResponse.AccessToken, DateTime.UtcNow.AddSeconds(tokenResponse.ExpiresIn));

src/Sdk/WebApi/WebApi/VssConnection.cs

@@ -100,7 +100,6 @@ namespace GitHub.Services.WebApi
             IDictionary<String, String> parameters,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssConnection.ConnectAsync");
             CheckForDisposed();
             // Set the connectMode on the credential's FederatedPrompt
             if (Credentials.Federated != null && Credentials.Federated.Prompt != null)

src/Sdk/WebApi/WebApi/VssHttpClientBase.cs

@@ -390,7 +390,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 1");
             return SendAsync<T>(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken);
         }
 
@@ -405,7 +404,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 2");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -424,7 +422,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 3");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, additionalHeaders, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -458,7 +455,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 4");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -477,7 +473,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 5");
             using (VssTraceActivity.GetOrCreate().EnterCorrelationScope())
             using (HttpRequestMessage requestMessage = await CreateRequestMessageAsync(method, locationId, routeValues, version, content, queryParameters, userState, cancellationToken).ConfigureAwait(false))
             {
@@ -506,7 +501,6 @@ namespace GitHub.Services.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             String mediaType = c_jsonMediaType)
         {
-            // System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 1");
             return CreateRequestMessageAsync(method, null, locationId, routeValues, version, content, queryParameters, userState, cancellationToken, mediaType);
         }
 
@@ -532,7 +526,6 @@ namespace GitHub.Services.WebApi
             CancellationToken cancellationToken = default(CancellationToken),
             String mediaType = c_jsonMediaType)
         {
-            // System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 2");
             // Lookup the location
             ApiResourceLocation location = await GetResourceLocationAsync(locationId, userState, cancellationToken).ConfigureAwait(false);
             if (location == null)
@@ -562,7 +555,6 @@ namespace GitHub.Services.WebApi
             IEnumerable<KeyValuePair<String, String>> queryParameters = null,
             String mediaType = c_jsonMediaType)
         {
-            // System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 3");
             return CreateRequestMessage(method, null, location, routeValues, version, content, queryParameters, mediaType);
         }
 
@@ -586,7 +578,6 @@ namespace GitHub.Services.WebApi
             IEnumerable<KeyValuePair<String, String>> queryParameters = null,
             String mediaType = c_jsonMediaType)
         {
-            // System.Console.WriteLine("VssHttpClientBase.CreateRequestMessageAsync 4");
             CheckForDisposed();
             // Negotiate the request version to send
             ApiResourceVersion requestVersion = NegotiateRequestVersion(location, version);
@@ -758,14 +749,12 @@ namespace GitHub.Services.WebApi
             //from deadlocking...
             using (HttpResponseMessage response = await this.SendAsync(message, userState, cancellationToken).ConfigureAwait(false))
             {
-                // System.Console.WriteLine("VssHttpClientBase.SendAsync 6");
                 return await ReadContentAsAsync<T>(response, cancellationToken).ConfigureAwait(false);
             }
         }
 
         protected async Task<T> ReadContentAsAsync<T>(HttpResponseMessage response, CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine($"VssHttpClientBase.ReadContentAsAsync {response.Headers}");
             CheckForDisposed();
             Boolean isJson = IsJsonResponse(response);
             bool mismatchContentType = false;
@@ -777,20 +766,17 @@ namespace GitHub.Services.WebApi
                     !typeof(Byte[]).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo()) &&
                     !typeof(JObject).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo()))
                 {
-                    // System.Console.WriteLine("VssHttpClientBase.ReadContentAsAsync: isJson 1");
                     // expect it to come back wrapped, if it isn't it is a bug!
                     var wrapper = await ReadJsonContentAsync<VssJsonCollectionWrapper<T>>(response, cancellationToken).ConfigureAwait(false);
                     return wrapper.Value;
                 }
                 else if (isJson)
                 {
-                    // System.Console.WriteLine("VssHttpClientBase.ReadContentAsAsync: isJson 2");
                     return await ReadJsonContentAsync<T>(response, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (JsonReaderException)
             {
-                // System.Console.WriteLine("VssHttpClientBase.ReadContentAsAsync: mismatchContentType");
                 // We thought the content was JSON but failed to parse. 
                 // In this case, do nothing and utilize the HandleUnknownContentType call below
                 mismatchContentType = true;
@@ -816,7 +802,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 7");
             // the default in httpClient for HttpCompletionOption is ResponseContentRead so that is what we do here
             return this.SendAsync(
                 message,
@@ -831,7 +816,6 @@ namespace GitHub.Services.WebApi
             Object userState = null,
             CancellationToken cancellationToken = default(CancellationToken))
         {
-            // System.Console.WriteLine("VssHttpClientBase.SendAsync 8");
             CheckForDisposed();
             if (message.Headers.UserAgent != null)
             {
@@ -867,7 +851,6 @@ namespace GitHub.Services.WebApi
                 //ConfigureAwait(false) enables the continuation to be run outside
                 //any captured SyncronizationContext (such as ASP.NET's) which keeps things
                 //from deadlocking...
-                // System.Console.WriteLine($"VssHttpClientBase.SendAsync 8: Calling Client.SendAsync {message}");
                 HttpResponseMessage response = await Client.SendAsync(message, completionOption, cancellationToken).ConfigureAwait(false);
 
                 // Inject delay or failure for testing
@@ -885,7 +868,6 @@ namespace GitHub.Services.WebApi
         [Obsolete("Use VssHttpClientBase.HandleResponseAsync instead")]
         protected virtual void HandleResponse(HttpResponseMessage response)
         {
-            // System.Console.WriteLine("VssHttpClientBase.HandleResponse 1");
 
         }
 
@@ -893,7 +875,6 @@ namespace GitHub.Services.WebApi
             HttpResponseMessage response,
             CancellationToken cancellationToken)
         {
-            // System.Console.WriteLine($"VssHttpClientBase.HandleResponse 2 status code {response.StatusCode} headers {response.Headers}");
             response.Trace();
             VssHttpEventSource.Log.HttpRequestStop(VssTraceActivity.Current, response);
 
@@ -905,7 +886,6 @@ namespace GitHub.Services.WebApi
             }
             else if (ShouldThrowError(response))
             {
-                // System.Console.WriteLine("VssHttpClientBase.HandleResponse: Should throw error");
                 Exception exToThrow = null;
                 if (IsJsonResponse(response))
                 {
@@ -929,7 +909,6 @@ namespace GitHub.Services.WebApi
                     {
                         message = response.ReasonPhrase;
                     }
-                    // System.Console.WriteLine($"VssHttpClientBase.HandleResponse: Exception message {message}");
                     exToThrow = new VssServiceResponseException(response.StatusCode, message, exToThrow);
                 }
 

src/Test/L0/Container/DockerUtilL0.cs

@@ -144,5 +144,48 @@ namespace GitHub.Runner.Common.Tests.Worker.Container
             var actual = DockerUtil.ParseRegistryHostnameFromImageName(input);
             Assert.Equal(expected, actual);
         }
+
+        [Theory]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        [InlineData("dockerhub/repo", false)]
+        [InlineData("debian:latest", false)]
+        [InlineData("something/dockerfileimage", false)]
+        [InlineData("ghcr.io/docker/dockerfile", true)] // should be false but might break the current workflows
+        [InlineData("Dockerfile", true)]
+        [InlineData("Dockerfile.", true)]
+        [InlineData(".Dockerfile", true)]
+        [InlineData(".Dockerfile.", false)]
+        [InlineData("dockerfile", true)]
+        [InlineData("dockerfile.", true)]
+        [InlineData(".dockerfile", true)]
+        [InlineData(".dockerfile.", false)]
+        [InlineData("Dockerfile.test", true)]
+        [InlineData("test.Dockerfile", true)]
+        [InlineData("docker/dockerfile:latest", false)]
+        [InlineData("/some/path/dockerfile:latest", false)]
+        [InlineData("dockerfile:latest", false)]
+        [InlineData("Dockerfile:latest", false)]
+        [InlineData("dockerfile-latest", false)]
+        [InlineData("Dockerfile-latest", false)]
+        [InlineData("dockerfile.latest", true)]
+        [InlineData("Dockerfile.latest", true)]
+        [InlineData("../dockerfile/dockerfileone", false)]
+        [InlineData("../Dockerfile/dockerfileone", false)]
+        [InlineData("../dockerfile.test", true)]
+        [InlineData("../Dockerfile.test", true)]
+        [InlineData("./dockerfile/image", false)]
+        [InlineData("./Dockerfile/image", false)]
+        [InlineData("example/Dockerfile.test", true)]
+        [InlineData("./example/Dockerfile.test", true)]
+        [InlineData("example/test.dockerfile", true)]
+        [InlineData("./example/test.dockerfile", true)]
+        [InlineData("docker://Dockerfile", false)]
+        [InlineData("docker://ubuntu:latest", false)]
+        public void IsDockerfile(string input, bool expected)
+        {
+            var actual = DockerUtil.IsDockerfile(input);
+            Assert.Equal(expected, actual);
+        }
     }
 }

src/Test/L0/Listener/CommandSettingsL0.cs

@@ -708,33 +708,85 @@ namespace GitHub.Runner.Common.Tests
             }
         }
 
-        [Fact]
+        [Theory]
+        [InlineData("configure", "once")]
+        [InlineData("remove", "disableupdate")]
+        [InlineData("remove", "ephemeral")]
+        [InlineData("remove", "once")]
+        [InlineData("remove", "replace")]
+        [InlineData("remove", "runasservice")]
+        [InlineData("remove", "unattended")]
+        [InlineData("run", "disableupdate")]
+        [InlineData("run", "ephemeral")]
+        [InlineData("run", "replace")]
+        [InlineData("run", "runasservice")]
+        [InlineData("run", "unattended")]
+        [InlineData("warmup", "disableupdate")]      
+        [InlineData("warmup", "ephemeral")]     
+        [InlineData("warmup", "once")]   
+        [InlineData("warmup", "replace")]      
+        [InlineData("warmup", "runasservice")]   
+        [InlineData("warmup", "unattended")]
         [Trait("Level", "L0")]
         [Trait("Category", nameof(CommandSettings))]
-        public void ValidateFlags()
+        public void ValidateInvalidFlagCommandCombination(string validCommand, string flag)
         {
             using (TestHostContext hc = CreateTestContext())
             {
                 // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { "--badflag" });
+                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{flag}" });
 
                 // Assert.
-                Assert.Contains("badflag", command.Validate());
+                Assert.Contains(flag, command.Validate());
             }
         }
 
-        [Fact]
+        [Theory]
+        [InlineData("remove", "auth", "bar arg value")]
+        [InlineData("remove", "labels", "bar arg value")]
+        [InlineData("remove", "monitorsocketaddress", "bar arg value")]
+        [InlineData("remove", "name", "bar arg value")]
+        [InlineData("remove", "runnergroup", "bar arg value")]
+        [InlineData("remove", "url", "bar arg value")]
+        [InlineData("remove", "username", "bar arg value")]
+        [InlineData("remove", "windowslogonaccount", "bar arg value")]
+        [InlineData("remove", "windowslogonpassword", "bar arg value")]
+        [InlineData("remove", "work", "bar arg value")]
+        [InlineData("run", "auth", "bad arg value")]
+        [InlineData("run", "labels", "bad arg value")]
+        [InlineData("run", "monitorsocketaddress", "bad arg value")]
+        [InlineData("run", "name", "bad arg value")]
+        [InlineData("run", "pat", "bad arg value")]
+        [InlineData("run", "runnergroup", "bad arg value")]
+        [InlineData("run", "token", "bad arg value")]
+        [InlineData("run", "url", "bad arg value")]
+        [InlineData("run", "username", "bad arg value")]
+        [InlineData("run", "windowslogonaccount", "bad arg value")]
+        [InlineData("run", "windowslogonpassword", "bad arg value")]
+        [InlineData("run", "work", "bad arg value")]
+        [InlineData("warmup", "auth", "bad arg value")]
+        [InlineData("warmup", "labels", "bad arg value")]
+        [InlineData("warmup", "monitorsocketaddress", "bad arg value")]
+        [InlineData("warmup", "name", "bad arg value")]
+        [InlineData("warmup", "pat", "bad arg value")]
+        [InlineData("warmup", "runnergroup", "bad arg value")]
+        [InlineData("warmup", "token", "bad arg value")]
+        [InlineData("warmup", "url", "bad arg value")]
+        [InlineData("warmup", "username", "bad arg value")]
+        [InlineData("warmup", "windowslogonaccount", "bad arg value")]
+        [InlineData("warmup", "windowslogonpassword", "bad arg value")]
+        [InlineData("warmup", "work", "bad arg value")]
         [Trait("Level", "L0")]
         [Trait("Category", nameof(CommandSettings))]
-        public void ValidateArgs()
+        public void ValidateInvalidArgCommandCombination(string validCommand, string arg, string argValue)
         {
             using (TestHostContext hc = CreateTestContext())
             {
                 // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { "--badargname", "bad arg value" });
+                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{arg}", argValue });
 
                 // Assert.
-                Assert.Contains("badargname", command.Validate());
+                Assert.Contains(arg, command.Validate());
             }
         }
 
@@ -758,6 +810,73 @@ namespace GitHub.Runner.Common.Tests
             }
         }
 
+        [Theory]
+        [InlineData("configure", "help")]
+        [InlineData("configure", "version")]
+        [InlineData("configure", "commit")]
+        [InlineData("configure", "check")]
+        [InlineData("configure", "disableupdate")]
+        [InlineData("configure", "ephemeral")]
+        [InlineData("configure", "replace")]
+        [InlineData("configure", "runasservice")]
+        [InlineData("configure", "unattended")]
+        [InlineData("remove", "help")]
+        [InlineData("remove", "version")]
+        [InlineData("remove", "commit")]
+        [InlineData("remove", "check")]
+        [InlineData("run", "help")]
+        [InlineData("run", "version")]
+        [InlineData("run", "commit")]
+        [InlineData("run", "check")]
+        [InlineData("run", "once")]
+        [InlineData("warmup", "help")]
+        [InlineData("warmup", "version")]
+        [InlineData("warmup", "commit")]
+        [InlineData("warmup", "check")]
+        [Trait("Level", "L0")]
+        [Trait("Category", nameof(CommandSettings))]
+        public void ValidateGoodFlagCommandCombination(string validCommand, string flag)
+        {
+            using (TestHostContext hc = CreateTestContext())
+            {
+                // Arrange.
+                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{flag}" });
+
+                // Assert.
+                Assert.True(command.Validate().Count == 0);
+            }
+        }
+
+        [Theory]
+        [InlineData("configure", "auth", "good arg value")]
+        [InlineData("configure", "labels", "good arg value")]
+        [InlineData("configure", "monitorsocketaddress", "good arg value")]
+        [InlineData("configure", "name", "good arg value")]
+        [InlineData("configure", "pat", "good arg value")]
+        [InlineData("configure", "runnergroup", "good arg value")]
+        [InlineData("configure", "token", "good arg value")]
+        [InlineData("configure", "url", "good arg value")]
+        [InlineData("configure", "username", "good arg value")]
+        [InlineData("configure", "windowslogonaccount", "good arg value")]
+        [InlineData("configure", "windowslogonpassword", "good arg value")]
+        [InlineData("configure", "work", "good arg value")]
+        [InlineData("remove", "token", "good arg value")]
+        [InlineData("remove", "pat", "good arg value")]
+        [InlineData("run", "startuptype", "good arg value")]
+        [Trait("Level", "L0")]
+        [Trait("Category", nameof(CommandSettings))]
+        public void ValidateGoodArgCommandCombination(string validCommand, string arg, string argValue)
+        {
+            using (TestHostContext hc = CreateTestContext())
+            {
+                // Arrange.
+                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{arg}", argValue });
+
+                // Assert.
+                Assert.True(command.Validate().Count == 0);
+            }
+        }
+
         private TestHostContext CreateTestContext([CallerMemberName] string testName = "")
         {
             TestHostContext hc = new TestHostContext(this, testName);

src/Test/L0/Worker/CreateStepSummaryCommandL0.cs

@@ -33,7 +33,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (var hostContext = Setup(featureFlagState: "false"))
             {
                 var stepSummaryFile = Path.Combine(_rootDirectory, "feature-off");
-                
+
                 _createStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
                 _jobExecutionContext.Complete();
 
@@ -117,7 +117,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (var hostContext = Setup())
             {
                 var stepSummaryFile = Path.Combine(_rootDirectory, "empty-file");
-                File.WriteAllBytes(stepSummaryFile, new byte[128 * 1024 + 1]);
+                File.WriteAllBytes(stepSummaryFile, new byte[CreateStepSummaryCommand.AttachmentSizeLimit + 1]);
 
                 _createStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
                 _jobExecutionContext.Complete();

src/Test/L0/Worker/ExecutionContextL0.cs

@@ -6,6 +6,8 @@ using System.Threading;
 using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Worker;
+using GitHub.Runner.Worker.Container;
+using GitHub.Runner.Worker.Handlers;
 using Moq;
 using Xunit;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
@@ -724,5 +726,149 @@ namespace GitHub.Runner.Common.Tests.Worker
 
             return hc;
         }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void GetExpressionValues_ContainerStepHost()
+        {
+            using (TestHostContext hc = CreateTestContext())
+            {
+                const string source = "/home/username/Projects/work/runner/_layout";
+                var containerInfo = new ContainerInfo();
+                containerInfo.ContainerId = "test";
+
+                containerInfo.AddPathTranslateMapping($"{source}/_work", "/__w");
+                containerInfo.AddPathTranslateMapping($"{source}/_temp", "/__t");
+                containerInfo.AddPathTranslateMapping($"{source}/externals", "/__e");
+
+                containerInfo.AddPathTranslateMapping($"{source}/_work/_temp/_github_home", "/github/home");
+                containerInfo.AddPathTranslateMapping($"{source}/_work/_temp/_github_workflow", "/github/workflow");
+
+                foreach (var v in new List<string>() {
+                    $"{source}/_work",
+                    $"{source}/externals",
+                    $"{source}/_work/_temp",
+                    $"{source}/_work/_actions",
+                    $"{source}/_work/_tool",
+                })
+                {
+                    containerInfo.MountVolumes.Add(new MountVolume(v, containerInfo.TranslateToContainerPath(v)));
+                };
+
+                var stepHost = new ContainerStepHost();
+                stepHost.Container = containerInfo;
+
+                var ec = new Runner.Worker.ExecutionContext();
+                ec.Initialize(hc);
+
+                var inputGithubContext = new GitHubContext();
+                var inputeRunnerContext = new RunnerContext();
+
+                // string context data
+                inputGithubContext["action_path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_actions/owner/composite/main");
+                inputGithubContext["action"] = new StringContextData("__owner_composite");
+                inputGithubContext["api_url"] = new StringContextData("https://api.github.com/custom/path");
+                inputGithubContext["env"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_runner_file_commands/set_env_265698aa-7f38-40f5-9316-5c01a3153672");
+                inputGithubContext["path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_runner_file_commands/add_path_265698aa-7f38-40f5-9316-5c01a3153672");
+                inputGithubContext["event_path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_github_workflow/event.json");
+                inputGithubContext["repository"] = new StringContextData("owner/repo-name");
+                inputGithubContext["run_id"] = new StringContextData("2033211332");
+                inputGithubContext["workflow"] = new StringContextData("Name of Workflow");
+                inputGithubContext["workspace"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/step-order/step-order");
+                inputeRunnerContext["temp"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp");
+                inputeRunnerContext["tool_cache"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_tool");
+
+                // dictionary context data
+                var githubEvent = new DictionaryContextData();
+                githubEvent["inputs"] = null;
+                githubEvent["ref"] = new StringContextData("refs/heads/main");
+                githubEvent["repository"] = new DictionaryContextData();
+                githubEvent["sender"] = new DictionaryContextData();
+                githubEvent["workflow"] = new StringContextData(".github/workflows/composite_step_host_translate.yaml");
+
+                inputGithubContext["event"] = githubEvent;
+
+                ec.ExpressionValues["github"] = inputGithubContext;
+                ec.ExpressionValues["runner"] = inputeRunnerContext;
+
+                var ecExpect = new Runner.Worker.ExecutionContext();
+                ecExpect.Initialize(hc);
+
+                var expectedGithubEvent = new DictionaryContextData();
+                expectedGithubEvent["inputs"] = null;
+                expectedGithubEvent["ref"] = new StringContextData("refs/heads/main");
+                expectedGithubEvent["repository"] = new DictionaryContextData();
+                expectedGithubEvent["sender"] = new DictionaryContextData();
+                expectedGithubEvent["workflow"] = new StringContextData(".github/workflows/composite_step_host_translate.yaml");
+                var expectedGithubContext = new GitHubContext();
+                var expectedRunnerContext = new RunnerContext();
+                expectedGithubContext["action_path"] = new StringContextData("/__w/_actions/owner/composite/main");
+                expectedGithubContext["action"] = new StringContextData("__owner_composite");
+                expectedGithubContext["api_url"] = new StringContextData("https://api.github.com/custom/path");
+                expectedGithubContext["env"] = new StringContextData("/__w/_temp/_runner_file_commands/set_env_265698aa-7f38-40f5-9316-5c01a3153672");
+                expectedGithubContext["path"] = new StringContextData("/__w/_temp/_runner_file_commands/add_path_265698aa-7f38-40f5-9316-5c01a3153672");
+                expectedGithubContext["event_path"] = new StringContextData("/github/workflow/event.json");
+                expectedGithubContext["repository"] = new StringContextData("owner/repo-name");
+                expectedGithubContext["run_id"] = new StringContextData("2033211332");
+                expectedGithubContext["workflow"] = new StringContextData("Name of Workflow");
+                expectedGithubContext["workspace"] = new StringContextData("/__w/step-order/step-order");
+                expectedGithubContext["event"] = expectedGithubEvent;
+                expectedRunnerContext["temp"] = new StringContextData("/__w/_temp");
+                expectedRunnerContext["tool_cache"] = new StringContextData("/__w/_tool");
+
+                ecExpect.ExpressionValues["github"] = expectedGithubContext;
+                ecExpect.ExpressionValues["runner"] = expectedRunnerContext;
+
+                var translatedExpressionValues = ec.GetExpressionValues(stepHost);
+
+                foreach (var contextName in new string[] { "github", "runner" })
+                {
+                    var dict = translatedExpressionValues[contextName].AssertDictionary($"expected context github to be a dictionary");
+                    var expectedExpressionValues = ecExpect.ExpressionValues[contextName].AssertDictionary("expect dict");
+                    foreach (var key in dict.Keys.ToList())
+                    {
+                        if (dict[key] is StringContextData)
+                        {
+                            var expect = dict[key].AssertString("expect string");
+                            var outcome = expectedExpressionValues[key].AssertString("expect string");
+                            Assert.Equal(expect.Value, outcome.Value);
+                        }
+                        else if (dict[key] is DictionaryContextData || dict[key] is CaseSensitiveDictionaryContextData)
+                        {
+                            var expectDict = dict[key].AssertDictionary("expect dict");
+                            var actualDict = expectedExpressionValues[key].AssertDictionary("expect dict");
+                            Assert.True(ExpressionValuesAssertEqual(expectDict, actualDict));
+                        }
+                    }
+                }
+            }
+        }
+
+        private bool ExpressionValuesAssertEqual(DictionaryContextData expect, DictionaryContextData actual)
+        {
+            foreach (var key in expect.Keys.ToList())
+            {
+                if (expect[key] is StringContextData)
+                {
+                    var expectValue = expect[key].AssertString("expect string");
+                    var actualValue = actual[key].AssertString("expect string");
+                    if (expectValue.Equals(actualValue))
+                    {
+                        return false;
+                    }
+                }
+                else if (expect[key] is DictionaryContextData || expect[key] is CaseSensitiveDictionaryContextData)
+                {
+                    var expectDict = expect[key].AssertDictionary("expect dict");
+                    var actualDict = actual[key].AssertDictionary("expect dict");
+                    if (!ExpressionValuesAssertEqual(expectDict, actualDict))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
     }
-}
+}

src/Test/L0/Worker/OutputManagerL0.cs

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Runtime.CompilerServices;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Container;
@@ -937,6 +937,19 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CaptureTelemetryForGitUnsafeRepository()
+        {
+            using (Setup())
+            using (_outputManager)
+            {
+                Process("fatal: unsafe repository ('/github/workspace' is owned by someone else)");
+                Assert.Contains("fatal: unsafe repository ('/github/workspace' is owned by someone else)", _executionContext.Object.StepTelemetry.ErrorMessages);
+            }
+        }
+
         private TestHostContext Setup(
             [CallerMemberName] string name = "",
             IssueMatchersConfig matchers = null,
@@ -962,6 +975,8 @@ namespace GitHub.Runner.Common.Tests.Worker
                     Variables = _variables,
                     WriteDebug = true,
                 });
+            _executionContext.Setup(x => x.StepTelemetry)
+                .Returns(new DTWebApi.ActionsStepTelemetry());
             _executionContext.Setup(x => x.GetMatchers())
                 .Returns(matchers?.Matchers ?? new List<IssueMatcherConfig>());
             _executionContext.Setup(x => x.Add(It.IsAny<OnMatcherChanged>()))

src/Test/L0/Worker/StepHostL0.cs

@@ -7,6 +7,9 @@ using Xunit;
 using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Handlers;
 using GitHub.Runner.Worker.Container;
+using GitHub.DistributedTask.Pipelines.ContextData;
+using System.Linq;
+using GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Common.Tests.Worker
 {

src/dev.sh

@@ -2,7 +2,7 @@
 
 ###############################################################################
 #  
-#  ./dev.sh build/layout/test/package [Debug/Release] [linux-x64|linux-x86|linux-arm64|linux-arm|osx-x64|win-x64|win-x86] [use-broker]
+#  ./dev.sh build/layout/test/package [Debug/Release]
 #
 ###############################################################################
 
@@ -11,7 +11,6 @@ set -e
 DEV_CMD=$1
 DEV_CONFIG=$2
 DEV_TARGET_RUNTIME=$3
-DEV_USE_BROKER=$4
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 LAYOUT_DIR="$SCRIPT_DIR/../_layout"
@@ -82,13 +81,6 @@ elif [[ "$CURRENT_PLATFORM" == 'darwin' ]]; then
     fi
 fi
 
-if [ -n "$DEV_USE_BROKER" ]; then
-    USE_BROKER='-p:USE_BROKER="true"'
-else
-    USE_BROKER=''
-fi
-
-
 function failed()
 {
     local error=${1:-Undefined error}
@@ -122,13 +114,13 @@ function heading()
 function build ()
 {
     heading "Building ..."
-    dotnet msbuild -t:Build -p:PackageRuntime="${RUNTIME_ID}" -p:BUILDCONFIG="${BUILD_CONFIG}" -p:RunnerVersion="${RUNNER_VERSION}" $USE_BROKER ./dir.proj || failed build
+    dotnet msbuild -t:Build -p:PackageRuntime="${RUNTIME_ID}" -p:BUILDCONFIG="${BUILD_CONFIG}" -p:RunnerVersion="${RUNNER_VERSION}" ./dir.proj || failed build
 }
 
 function layout ()
 {
     heading "Create layout ..."
-    dotnet msbuild -t:layout -p:PackageRuntime="${RUNTIME_ID}" -p:BUILDCONFIG="${BUILD_CONFIG}" -p:RunnerVersion="${RUNNER_VERSION}" $USE_BROKER ./dir.proj || failed build
+    dotnet msbuild -t:layout -p:PackageRuntime="${RUNTIME_ID}" -p:BUILDCONFIG="${BUILD_CONFIG}" -p:RunnerVersion="${RUNNER_VERSION}" ./dir.proj || failed build
 
     #change execution flag to allow running with sudo
     if [[ ("$CURRENT_PLATFORM" == "linux") || ("$CURRENT_PLATFORM" == "darwin") ]]; then

src/runnerversion

@@ -1 +1 @@
-2.289.2
+2.291.0