Sketch enabling debugging.

src/Microsoft.Tye.Core/ApplicationFactory.cs

@@ -343,6 +343,7 @@ namespace Microsoft.Tye
 
                         var node = new NodeServiceBuilder(configService.Name, packagePath, ServiceSource.Configuration)
                         {
+                            EnableDebugging = configService.Node.EnableDebugging,
                             Replicas = configService.Replicas ?? 1,
                             Script = configService.Node.Script
                         };

src/Microsoft.Tye.Core/ConfigModel/ConfigNode.cs

@@ -8,6 +8,8 @@ namespace Microsoft.Tye.ConfigModel
 {
     public class ConfigNode
     {
+        public bool? EnableDebugging { get; set; }
+
         [Required]
         public string Package { get; set; } = default!;
 

src/Microsoft.Tye.Core/NodeServiceBuilder.cs

@@ -14,6 +14,8 @@ namespace Microsoft.Tye
             PackagePath = packagePath;
         }
 
+        public bool? EnableDebugging { get; set; }
+
         public string PackagePath { get; set; }
 
         public string? Script { get; set; }

src/Microsoft.Tye.Core/Serialization/ConfigServiceParser.cs

@@ -239,15 +239,6 @@ namespace Tye.Serialization
             }
         }
 
-        private static void HandleNode(YamlSequenceNode yamlSequenceNode, ConfigNode node)
-        {
-            foreach (var child in yamlSequenceNode.Children)
-            {
-                YamlParser.ThrowIfNotYamlMapping(child);
-                HandleNode((YamlMappingNode)child, node);
-            }
-        }
-
         private static void HandleNode(YamlMappingNode yamlMappingNode, ConfigNode node)
         {
             foreach (var child in yamlMappingNode.Children)
@@ -256,11 +247,19 @@ namespace Tye.Serialization
 
                 switch (key)
                 {
+                    case "enableDebugging":
+                        if (!bool.TryParse(YamlParser.GetScalarValue(key, child.Value), out var enableDebugging))
+                        {
+                            throw new TyeYamlException(child.Value.Start, CoreStrings.FormatMustBeABoolean(key));
+                        }
+
+                        node.EnableDebugging = enableDebugging;
+                        break;
                     case "package":
-                        node.Package =  YamlParser.GetScalarValue("package", child.Value);
+                        node.Package =  YamlParser.GetScalarValue(key, child.Value);
                         break;
                     case "script":
-                        node.Script =  YamlParser.GetScalarValue("script", child.Value);
+                        node.Script =  YamlParser.GetScalarValue(key, child.Value);
                         break;
                     default:
                         throw new TyeYamlException(child.Key.Start, CoreStrings.FormatUnrecognizedKey(key));

src/Microsoft.Tye.Extensions/Dapr/DaprExtension.cs

@@ -78,8 +78,14 @@ namespace Microsoft.Tye.Extensions.Dapr
 
                 // For local run, enumerate all projects, and add services for each dapr proxy.
                 var projects = context.Application.Services.OfType<ProjectServiceBuilder>().Cast<LaunchedServiceBuilder>();
+                // TODO: Is there a better hierarchy to capture all "launched" services (can we just use LaunchedServiceBuilder)?
+                var node = context.Application.Services.OfType<NodeServiceBuilder>().Cast<LaunchedServiceBuilder>();
                 var executables = context.Application.Services.OfType<ExecutableServiceBuilder>().Cast<LaunchedServiceBuilder>();
-                var services = projects.Concat(executables).ToList();
+                var services =
+                    projects
+                        .Concat(node)
+                        .Concat(executables)
+                        .ToList();
 
                 foreach (var project in services)
                 {

src/tye/ApplicationBuilderExtensions.cs

@@ -169,7 +169,8 @@ namespace Microsoft.Tye
 
                     var main = mainNode.Value;
 
-                    string args = $"{main}";
+                    string enableDebuggingArg = !node.EnableDebugging.HasValue || node.EnableDebugging.Value ? "--inspect ": "";
+                    string args = $"{enableDebuggingArg}{main}";
 
                     runInfo = new ExecutableRunInfo(executablePath, workingDirectory, args);
                     replicas = node.Replicas;