fix: correct endpoint name derivation for needsDeployment=false and surface exceptions properly (#296)

For non-Azure-hosted agents (dev tunnels, external endpoints), the endpoint name used at
deletion time could differ from the name used at registration when WebAppName was also
present in config. BotName prioritizes WebAppName, while RegisterBlueprintMessagingEndpointAsync
always derives the name from the MessagingEndpoint URL host. This mismatch caused the delete
to return "not found", the CLI to proceed, and the subsequent create to fail with
"MsaAppId is already in use".

- Add EndpointHelper.GetEndpointNameFromUrl() to derive endpoint names from URLs consistently
- Use it in UpdateEndpointAsync (BlueprintSubcommand) and CleanupCommand for needsDeployment=false
- Extract ResolveEndpointName() helper in CleanupCommand to avoid duplication
- Fix --update-endpoint catch block to route Agent365Exception through ExceptionHandler
  (suppresses stack trace for user errors, honors correct exit code)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: sellakumaran

src/Directory.Packages.props

@@ -34,6 +34,10 @@
     <PackageVersion Include="Azure.ResourceManager.AppService" Version="1.2.0" />
     <!-- Microsoft Graph -->
     <PackageVersion Include="Microsoft.Graph" Version="5.36.0" />
+    <!-- Transitive pin: resolves NU1107 conflict between Microsoft.Extensions.Http 9.x (needs >= 9.0.8)
+         and Microsoft.Kiota.Abstractions 1.7.2 (needs < 9.0.0). CentralPackageTransitivePinningEnabled
+         allows this pin to override the Kiota upper bound. -->
+    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="9.0.8" />
     <!-- Testing packages -->
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageVersion Include="xunit" Version="2.9.2" />

src/Microsoft.Agents.A365.DevTools.Cli/Commands/CleanupCommand.cs

@@ -741,7 +741,7 @@ private static async Task<bool> DeleteMessagingEndpointAsync(
         }
 
         logger.LogInformation("Deleting messaging endpoint registration...");
-        var endpointName = config.BotName; // BotName already returns a final, validated name
+        var endpointName = ResolveEndpointName(config);
 
         var endpointDeleted = await botConfigurator.DeleteEndpointWithAgentBlueprintAsync(
             endpointName,
@@ -787,8 +787,8 @@ private static async Task ExecuteEndpointOnlyCleanupAsync(
             return;
         }
 
-        // BotName already returns a final, validated name — no further processing needed
-        var endpointName = config.BotName;
+        // Get the actual endpoint name that will be used for deletion (truncated to 42 chars).
+        var endpointName = ResolveEndpointName(config);
 
         logger.LogInformation("");
         logger.LogInformation("Endpoint Cleanup Preview:");
@@ -842,4 +842,23 @@ private static async Task ExecuteEndpointOnlyCleanupAsync(
             return null;
         }
     }
+
+    /// <summary>
+    /// Resolves the Azure Bot Service endpoint name from config.
+    /// For needsDeployment=false, prefers BotMessagingEndpoint (updated after each registration)
+    /// over MessagingEndpoint (static) so that delete targets the currently registered endpoint.
+    /// </summary>
+    private static string ResolveEndpointName(Agent365Config config)
+    {
+        if (!config.NeedDeployment)
+        {
+            // Use BotMessagingEndpoint (updated by registration) over MessagingEndpoint (static).
+            var urlForName = !string.IsNullOrWhiteSpace(config.BotMessagingEndpoint)
+                ? config.BotMessagingEndpoint
+                : config.MessagingEndpoint;
+            if (!string.IsNullOrWhiteSpace(urlForName))
+                return EndpointHelper.GetEndpointNameFromUrl(urlForName, config.AgentBlueprintId);
+        }
+        return EndpointHelper.GetEndpointName(config.BotName);
+    }
 }

src/Microsoft.Agents.A365.DevTools.Cli/Commands/SetupSubcommands/BlueprintSubcommand.cs

@@ -199,10 +199,17 @@ await UpdateEndpointAsync(
                         botConfigurator: botConfigurator,
                         platformDetector: platformDetector);
                 }
+                catch (Agent365Exception ex)
+                {
+                    var logFilePath = ConfigService.GetCommandLogPath(CommandNames.Setup);
+                    ExceptionHandler.HandleAgent365Exception(ex, logger: logger, logFilePath: logFilePath);
+                    ExceptionHandler.ExitWithCleanup(ex.ExitCode);
+                }
                 catch (Exception ex)
                 {
-                    logger.LogError(ex, "Endpoint update failed: {Message}", ex.Message);
-                    Environment.Exit(1);
+                    logger.LogError("Endpoint update failed: {Message}", ex.Message);
+                    logger.LogDebug(ex, "Endpoint update failed - stack trace");
+                    ExceptionHandler.ExitWithCleanup(1);
                 }
                 return;
             }
@@ -1821,15 +1828,34 @@ public static async Task UpdateEndpointAsync(
         logger.LogInformation("");
 
         // Step 1: Delete existing endpoint if it exists
-        if (!string.IsNullOrWhiteSpace(setupConfig.BotName))
+        if (!string.IsNullOrWhiteSpace(setupConfig.MessagingEndpoint) || !string.IsNullOrWhiteSpace(setupConfig.BotName))
         {
             logger.LogInformation("Deleting existing messaging endpoint...");
             if (string.IsNullOrWhiteSpace(setupConfig.Location))
             {
                 logger.LogError("Location not found. Please confirm location is in the config file.");
                 throw new Exceptions.SetupValidationException("Location is required to delete the existing messaging endpoint.");
             }
-            var endpointName = setupConfig.BotName; // BotName already returns a final, validated name
+
+            // For needsDeployment=false, derive the endpoint name from the currently registered URL.
+            // BotMessagingEndpoint (generated config) is updated after every successful registration,
+            // so it reflects the actual registered endpoint name after any --update-endpoint calls.
+            // Fall back to MessagingEndpoint (static config) if BotMessagingEndpoint is not yet set.
+            string endpointName;
+            if (!setupConfig.NeedDeployment && (!string.IsNullOrWhiteSpace(setupConfig.BotMessagingEndpoint) || !string.IsNullOrWhiteSpace(setupConfig.MessagingEndpoint)))
+            {
+                var urlForName = !string.IsNullOrWhiteSpace(setupConfig.BotMessagingEndpoint)
+                    ? setupConfig.BotMessagingEndpoint
+                    : setupConfig.MessagingEndpoint;
+                endpointName = Services.Helpers.EndpointHelper.GetEndpointNameFromUrl(urlForName, setupConfig.AgentBlueprintId);
+            }
+            else
+            {
+                // When NeedDeployment=true, BotName is always non-empty (derived from WebAppName),
+                // so GetEndpointName(BotName) is safe here.
+                endpointName = Services.Helpers.EndpointHelper.GetEndpointName(setupConfig.BotName);
+            }
+
             var normalizedLocation = setupConfig.Location.Replace(" ", "").ToLowerInvariant();
 
             var deleted = await botConfigurator.DeleteEndpointWithAgentBlueprintAsync(

src/Microsoft.Agents.A365.DevTools.Cli/Services/Helpers/EndpointHelper.cs

@@ -36,6 +36,28 @@ public static string GetEndpointName(string name)
         return truncated;
     }
 
+    /// <summary>
+    /// Derives the Azure Bot Service endpoint name from a messaging URL.
+    /// Used for non-Azure-hosted agents (needsDeployment=false) to ensure the same
+    /// name is used consistently across setup, update, and cleanup operations.
+    /// </summary>
+    public static string GetEndpointNameFromUrl(string url, string? blueprintId = null)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            throw new SetupValidationException(
+                "Cannot derive endpoint name: URL must not be null or empty.");
+        }
+
+        if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
+        {
+            throw new SetupValidationException(
+                $"Cannot derive endpoint name: '{url}' is not a valid absolute URL.");
+        }
+
+        return GetEndpointNameFromHost(uri.Host, blueprintId);
+    }
+
     /// <summary>
     /// Derives a globally unique endpoint name from a URL hostname and an agent blueprint ID.
     /// </summary>

src/Tests/Microsoft.Agents.A365.DevTools.Cli.Tests/Services/Helpers/EndpointHelperTests.cs

@@ -124,6 +124,48 @@ public void GetEndpointName_WhenResultBecomesTooShort_ShouldThrowSetupValidation
             .WithMessage("*becomes too short after processing*");
     }
 
+    [Fact]
+    public void GetEndpointNameFromUrl_WithDevTunnelUrl_ReturnsHostBasedName()
+    {
+        // Arrange - dev tunnel URL (the customer's scenario)
+        var url = "https://x23kz7ll-3979-inc1-devtunnels-ms.devtunnels.ms/api/messages";
+
+        // Act
+        var result = EndpointHelper.GetEndpointNameFromUrl(url);
+
+        // Assert - full pre-truncation string: "x23kz7ll-3979-inc1-devtunnels-ms-devtunnels-ms-endpoint" (55 chars)
+        // Truncated to 42 chars: "x23kz7ll-3979-inc1-devtunnels-ms-devtunnel" (no trailing hyphen to strip)
+        result.Should().Be("x23kz7ll-3979-inc1-devtunnels-ms-devtunnel");
+        result.Length.Should().Be(42);
+    }
+
+    [Fact]
+    public void GetEndpointNameFromUrl_WithSimpleUrl_ReturnsExpectedName()
+    {
+        // Arrange
+        var url = "https://myapp.azurewebsites.net/api/messages";
+
+        // Act
+        var result = EndpointHelper.GetEndpointNameFromUrl(url);
+
+        // Assert
+        result.Should().Be("myapp-azurewebsites-net-endpoint");
+    }
+
+    [Fact]
+    public void GetEndpointNameFromUrl_WithNgrokUrl_ReturnsExpectedName()
+    {
+        // Arrange - ngrok free domain
+        var url = "https://distressingly-gnathonic-alonzo.ngrok-free.app/api/messages";
+
+        // Act
+        var result = EndpointHelper.GetEndpointNameFromUrl(url);
+
+        // Assert - same result as going through GetEndpointName with the host-based name
+        var expected = EndpointHelper.GetEndpointName("distressingly-gnathonic-alonzo-ngrok-free-app-endpoint");
+        result.Should().Be(expected);
+    }
+
     // GetEndpointNameFromHost tests
 
     [Fact]
@@ -201,6 +243,22 @@ public void GetEndpointNameFromHost_WithLongHost_TruncatesHostToFitWithinLimit()
         result.Length.Should().Be(42);
     }
 
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("not-a-url")]
+    [InlineData("relative/path")]
+    public void GetEndpointNameFromUrl_WithInvalidUrl_ShouldThrowSetupValidationException(string? input)
+    {
+        // Act
+        // input! suppresses the nullable warning intentionally — tests runtime null/invalid handling
+        // even though the parameter is declared non-nullable.
+        Action act = () => EndpointHelper.GetEndpointNameFromUrl(input!);
+
+        // Assert
+        act.Should().Throw<SetupValidationException>();
+    }
+
     [Theory]
     [InlineData(null)]
     [InlineData("")]