fix(ci): address cross-platform test races and Windows GCC toolchain flags

- Separate stderr in ScriptRunExecutor and prioritize for diagnostic parsing
- Make PythonTracebackParser summary and frames resilient to interleaved lines
- Differentiate GCC from Clang when adding Windows SDK flags in CppBuildAndRunScriptRunner (-imsvc is clang-only)
- Add -lws2_32 on Windows for GCC/Clang in CppBuildAndRunScriptRunner and CppNotebookKernel
- Record traffic log before closing response in FryHttpListenerServerEngine and add resilient poll wait in HttpServerEngineTests

Author: PrashantUnity

Services/Languages/Cpp/CppBuildAndRunScriptRunner.cs

@@ -15,6 +15,7 @@ public async Task<ScriptRunPlan> PlanAsync(ScriptRunContext context, Cancellatio
         var compilerPath = context.Toolchain.ExecutablePath;
         var fileName = Path.GetFileName(compilerPath.Replace('\\', '/'));
         var isCl = fileName.Equals("cl.exe", StringComparison.OrdinalIgnoreCase) || fileName.Equals("cl", StringComparison.OrdinalIgnoreCase);
+        var isClang = fileName.Contains("clang", StringComparison.OrdinalIgnoreCase);
 
         var normalizedSource = context.SourceFilePath.Replace('\\', '/');
         var fileBaseName = Path.GetFileNameWithoutExtension(normalizedSource);
@@ -77,15 +78,15 @@ public async Task<ScriptRunPlan> PlanAsync(ScriptRunContext context, Cancellatio
 
             if (host.IsWindows && windowsSdk != null)
             {
-                if (windowsSdk.HasMsvcHeaders)
+                if (isClang && windowsSdk.HasMsvcHeaders)
                 {
                     foreach (var inc in windowsSdk.IncludeDirectories)
                     {
                         compileArgs.Add("-imsvc");
                         compileArgs.Add(inc);
                     }
                 }
-                else if (windowsSdk.HasMinGw)
+                else if (isClang && windowsSdk.HasMinGw)
                 {
                     compileArgs.Add("--target=x86_64-w64-windows-gnu");
                     compileArgs.Add($"--sysroot={windowsSdk.MinGwSysroot}");
@@ -104,6 +105,10 @@ public async Task<ScriptRunPlan> PlanAsync(ScriptRunContext context, Cancellatio
             compileArgs.Add("-o");
             compileArgs.Add(binPath);
             compileArgs.Add(context.SourceFilePath);
+            if (host.IsWindows)
+            {
+                compileArgs.Add("-lws2_32");
+            }
         }
 
         var environment = await CppProcessEnvironment.ForAsync(host, context.Toolchain, ct);

Services/Languages/Cpp/CppNotebookKernel.cs

@@ -121,6 +121,10 @@ public async Task<KernelExecutionResult> ExecuteAsync(KernelExecutionRequest req
             compileArgs.Add("-o");
             compileArgs.Add(binPath);
             compileArgs.Add(sourcePath);
+            if (_host.IsWindows)
+            {
+                compileArgs.Add("-lws2_32");
+            }
         }
 
         var compileResult = await _host.RunAsync(compilerPath, compileArgs, TimeSpan.FromSeconds(30), ct).ConfigureAwait(false);

Services/Languages/Python/PythonTracebackParser.cs

@@ -120,7 +120,12 @@ private static int FindExceptionSummary(List<Line> lines)
             for (var j = i - 1; j >= 0; j--)
             {
                 if (FrameLine().IsMatch(lines[j].Text)) return i;
-                if (lines[j].Indent == 0 && lines[j].Text.Length > 0 && !IsHeading(lines[j].Text)) break;
+                if (lines[j].Indent == 0 && (lines[j].Text.StartsWith("During handling", StringComparison.Ordinal) ||
+                                             lines[j].Text.StartsWith("The above exception", StringComparison.Ordinal) ||
+                                             (ExceptionLine().IsMatch(lines[j].Text) && LooksLikeExceptionName(lines[j].Text))))
+                {
+                    break;
+                }
             }
         }
 
@@ -152,7 +157,9 @@ private static List<Frame> FramesOf(List<Line> lines, int summaryIndex)
             {
                 frames.Add(new Frame(frame.Groups["file"].Value, number, i));
             }
-            else if (line.Indent == 0 && line.Text.Length > 0)
+            else if (line.Indent == 0 && (line.Text.StartsWith("During handling", StringComparison.Ordinal) ||
+                                          line.Text.StartsWith("The above exception", StringComparison.Ordinal) ||
+                                          (ExceptionLine().IsMatch(line.Text) && LooksLikeExceptionName(line.Text))))
             {
                 break; // the end of an earlier, chained traceback
             }

Services/Processes/ScriptRunExecutor.cs

@@ -138,16 +138,23 @@ private async Task<ScriptRunResult> RunStepsAsync(
 
                 var step = plan.Steps[i];
                 var tail = new OutputTail(OutputTailLength);
+                var errorTail = new OutputTail(OutputTailLength);
                 void Receive(string text)
                 {
                     tail.Append(text);
                     onOutput(text);
                 }
+                void ReceiveError(string text)
+                {
+                    tail.Append(text);
+                    errorTail.Append(text);
+                    onOutput(text);
+                }
 
                 IManagedProcess process;
                 try
                 {
-                    process = _launcher.Start(step.IsBuildStep ? step.Spec : WithEnvironment(step.Spec, environment), Receive, Receive);
+                    process = _launcher.Start(step.IsBuildStep ? step.Spec : WithEnvironment(step.Spec, environment), Receive, ReceiveError);
                 }
                 catch (ProcessStartException ex)
                 {
@@ -168,9 +175,22 @@ void Receive(string text)
                 if (cts.IsCancellationRequested) return new ScriptRunResult(exitCode, true, clock.Elapsed, DiagnosticParseResult.Empty);
 
                 // Only a failed step is read for errors: a successful run can print text that merely looks like one.
-                var diagnostics = exitCode != 0 && parser != null
-                    ? parser.Parse(tail.ToString(), sourceFilePath)
-                    : DiagnosticParseResult.Empty;
+                // Standard error is prioritized because compilers and interpreters write tracebacks and errors there,
+                // avoiding interleaving with standard output.
+                var diagnostics = DiagnosticParseResult.Empty;
+                if (exitCode != 0 && parser != null)
+                {
+                    var errorOutput = errorTail.ToString();
+                    if (!string.IsNullOrWhiteSpace(errorOutput))
+                    {
+                        diagnostics = parser.Parse(errorOutput, sourceFilePath);
+                    }
+
+                    if (diagnostics.Diagnostics.Count == 0 && diagnostics.MissingDependency == null)
+                    {
+                        diagnostics = parser.Parse(tail.ToString(), sourceFilePath);
+                    }
+                }
 
                 if (step.IsBuildStep && exitCode != 0)
                 {

Services/Server/FryHttpListenerServerEngine.cs

@@ -313,11 +313,6 @@ private async Task HandleRequestAsync(HttpListenerContext httpContext, Cancellat
             }
             catch { }
         }
-        finally
-        {
-            try { response.Close(); } catch { }
-        }
-
         sw.Stop();
         Interlocked.Increment(ref _totalRequestsServed);
 
@@ -341,6 +336,12 @@ private async Task HandleRequestAsync(HttpListenerContext httpContext, Cancellat
         }
 
         RecordTraffic(logItem);
+
+        try
+        {
+            response.Close();
+        }
+        catch { }
     }
 
     public async Task<IServerResult> ExecuteLoopbackTestAsync(FryServerCellItem cell, FryServerTestHarnessItem testHarness, CancellationToken cancellationToken = default)

Tests/Server/HttpServerEngineTests.cs

@@ -73,6 +73,12 @@ public async Task ServerEngine_EndToEnd_ServesExternalHttpRequest()
             Assert.True(parsed.RootElement.GetProperty("hasOrders").GetBoolean());
             Assert.Equal("FryServer", parsed.RootElement.GetProperty("appName").GetString());
 
+            var deadline = DateTime.UtcNow.AddSeconds(5);
+            while (engine.TrafficLog.Count == 0 && DateTime.UtcNow < deadline)
+            {
+                await Task.Delay(20);
+            }
+
             Assert.True(engine.TotalRequestsServed >= 1);
             Assert.NotEmpty(engine.TrafficLog);
         }