Add path and openApiEndpoint options

Author: eisnstein

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.0.2 (2025-11-17)
+
+### Enhancements
+
+- Add `path` option to be able to give an absolute or relative path to the web app
+- Add `openApiEndpoint` option to be able to set a custom endpoint
+
 ## 0.0.1 (2025-11-15)
 
 - Initial release

README.md

@@ -2,6 +2,7 @@
 
 # RouteCheck
 
+[![NuGet Package](https://img.shields.io/nuget/vpre/RouteCheck)](https://nuget.org/packages/RouteCheck)
 [![License](https://img.shields.io/github/license/eisnstein/RouteCheck)](https://github.com/eisnstein/RouteCheck/blob/main/LICENSE)
 
 Check your API routes in your Terminal.
@@ -36,6 +37,22 @@ This should give you something like this:
 
 ![RouteCheck check example](https://github.com/eisnstein/RouteCheck/blob/main/src/Assets/routecheck-check.png)
 
+You can also provide a path to the web app via the `path` option:
+
+```sh
+routecheck --path /absolute/path/to/webapp
+
+# or
+
+routecheck -p relativ/path/to/webapp
+```
+
+If you use a custom OpenApi endpoint, you can set the `openApiEndpoint` option:
+
+```sh
+routecheck --openApiEndpoint /some/other/endpoint
+```
+
 For help run:
 
 ```sh

src/Commands/CheckCommand.cs

@@ -1,6 +1,7 @@
 using RouteCheck.Commands.Settings;
 using RouteCheck.Services;
 
+using Spectre.Console;
 using Spectre.Console.Cli;
 
 namespace RouteCheck.Commands;
@@ -13,14 +14,28 @@ public CheckCommand()
 
     public override async Task<int> ExecuteAsync(
         CommandContext _context,
-        CheckSettings _settings,
+        CheckSettings settings,
         CancellationToken _cancellationToken)
     {
-        var cwd = Directory.GetCurrentDirectory();
-        var (webApp, port) = await WebAppService.StartWebApp(cwd);
-        var openApiDoc = await OpenApiService.GetOpenApiJsonAsync(port);
+        string cwd = Directory.GetCurrentDirectory();
+        string pathToProject = Path.Combine(cwd, settings.Path ?? "");
+        if (!File.Exists(Path.Combine(pathToProject, "Program.cs")))
+        {
+            AnsiConsole.MarkupLine($"[red]Error:[/] The specified path '{pathToProject}' does not appear to be a valid .NET web application project directory. Missing 'Program.cs' file.");
+            return -1;
+        }
 
-        OutputService.DisplayRoutesFromSwagger(openApiDoc);
+        AnsiConsole.MarkupLine($"Starting web application from path: [grey]{pathToProject}[/] and waiting to be ready...");
+
+        var (webApp, port) = await WebAppService.StartWebApp(pathToProject);
+
+        AnsiConsole.MarkupLine($"Web application is running on port [grey]{port}[/]. Retrieving OpenAPI document...");
+
+        var openApiDoc = await OpenApiService.GetOpenApiJsonAsync(port, settings.OpenApiEndpoint);
+
+        Console.WriteLine();
+
+        OutputService.DisplayRoutesFromOpenApi(openApiDoc);
         WebAppService.StopWebApp(webApp);
 
         return 1;

src/Commands/Settings/CheckSettings.cs

@@ -6,7 +6,12 @@ namespace RouteCheck.Commands.Settings;
 
 public sealed class CheckSettings : CommandSettings
 {
-    [CommandOption("--csprojFile <Path>")]
-    [Description(@"Path to *.csproj file. (default .\*.csproj)")]
-    public string? PathToCsProjFile { get; set; }
+    [CommandOption("-p|--path <Path>")]
+    [Description(@"Path to web app for which to check routes. If not specified, the current directory will be used. Can be a relative or absolute path.")]
+    public string? Path { get; set; }
+
+    [CommandOption("--openApiEndpoint <OpenApiEndpoint>")]
+    [Description(@"OpenApi endpoint. If not specified, the default '/openapi/v1.json' will be used.")]
+    [DefaultValue("/openapi/v1.json")]
+    public required string OpenApiEndpoint { get; set; }
 }

src/Program.cs

@@ -24,7 +24,7 @@
         config.AddCommand<CheckCommand>("check")
             .WithAlias("c")
             .WithDescription("Check your routes. (default command)")
-            .WithExample(["check", "--csprojFile", ".\\examples\\csproj.xml"]);
+            .WithExample(["check", "--path", "/path/to/webapp"]);
     });
 
 return await app.RunAsync(args)

src/RouteCheck.csproj

@@ -11,7 +11,7 @@
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
     <ToolCommandName>routecheck</ToolCommandName>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>0.0.1</Version>
+    <Version>0.0.2</Version>
   </PropertyGroup>
 
   <PropertyGroup Label="Package Information">
@@ -21,7 +21,7 @@
     <PackageIcon>icon.png</PackageIcon>
     <PackageId>RouteCheck</PackageId>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageVersion>0.0.1</PackageVersion>
+    <PackageVersion>0.0.2</PackageVersion>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/eisnstein/RouteCheck</RepositoryUrl>
     <PackageReadmeFile>README.md</PackageReadmeFile>

src/Services/OpenApiService.cs

@@ -2,14 +2,27 @@
 
 public static class OpenApiService
 {
-    public static async Task<OpenApiDocument> GetOpenApiJsonAsync(int port)
+    public static async Task<OpenApiDocument> GetOpenApiJsonAsync(int port, string endpoint = "openapi/v1.json")
     {
-        var (openApiDoc, _) = await OpenApiDocument.LoadAsync($"http://localhost:{port}/openapi/v1.json");
+        var url = await BuildUrlAsync(port, endpoint);
+
+        var (openApiDoc, _) = await OpenApiDocument.LoadAsync(url);
         if (openApiDoc is null)
         {
             throw new Exception("Failed to load OpenAPI document.");
         }
 
         return openApiDoc;
     }
+
+    private static async Task<string> BuildUrlAsync(int port, string endpoint)
+    {
+        var url = new UriBuilder
+        {
+            Port = port,
+            Path = endpoint
+        }.Uri;
+
+        return url.ToString();
+    }
 }

src/Services/OutputService.cs

@@ -6,14 +6,13 @@ namespace RouteCheck.Services;
 
 public static class OutputService
 {
-    public static void DisplayRoutesFromSwagger(OpenApiDocument openApiDoc)
+    public static void DisplayRoutesFromOpenApi(OpenApiDocument openApiDoc)
     {
         var table = new Table();
         table.Border = TableBorder.Ascii2;
         table.AddColumn("Method");
         table.AddColumn("Path");
 
-        AnsiConsole.MarkupLine("Routes for [grey]API[/]:");
         foreach (KeyValuePair<string, IOpenApiPathItem> path in openApiDoc.Paths)
         {
             if (path.Value.Operations is null)

src/Services/WebAppService.cs

@@ -4,11 +4,12 @@
 
 public static class WebAppService
 {
-    public static async Task<(Process webApp, int port)> StartWebApp(string projectPath, int? port = null)
+    public static async Task<(Process webApp, int port)> StartWebApp(string projectPath, int? port = null, TimeSpan? startupTimeout = null)
     {
         port ??= GetAvailablePort();
         Process process = StartProcess("dotnet", $"run --urls=http://localhost:{port}", projectPath);
-        await Task.Delay(5000); // Allow app to start
+
+        await WaitForWebAppReadyAsync(process, port.Value, startupTimeout ?? TimeSpan.FromSeconds(20));
 
         return (process, port.Value);
     }
@@ -50,4 +51,48 @@ private static Process StartProcess(string fileName, string arguments, string wo
 
         return process;
     }
+
+    private static async Task WaitForWebAppReadyAsync(Process process, int port, TimeSpan timeout)
+    {
+        var stopwatch = Stopwatch.StartNew();
+
+        while (stopwatch.Elapsed < timeout)
+        {
+            if (process.HasExited)
+            {
+                throw new InvalidOperationException("The web application process exited before it started accepting requests.");
+            }
+
+            if (await IsPortOpenAsync(port))
+            {
+                return;
+            }
+
+            await Task.Delay(250);
+        }
+
+        throw new TimeoutException($"Timed out waiting for the web application to start listening on port {port}.");
+    }
+
+    private static async Task<bool> IsPortOpenAsync(int port)
+    {
+        try
+        {
+            using var client = new TcpClient();
+            var connectTask = client.ConnectAsync(IPAddress.Loopback, port);
+            var completed = await Task.WhenAny(connectTask, Task.Delay(500));
+
+            if (completed == connectTask)
+            {
+                await connectTask;
+                return true;
+            }
+        }
+        catch (SocketException)
+        {
+            // Port is not accepting connections yet
+        }
+
+        return false;
+    }
 }