Updates

Author: aritchie

readme.md

@@ -21,9 +21,9 @@ JWT, OpenAPI, HPACK, QPACK — is built on what is in the box.
 | [Shiny.Net.HttpServer.Mcp](https://www.nuget.org/packages/Shiny.Net.HttpServer.Mcp) | Model Context Protocol (Streamable HTTP) transport — host an MCP server without ASP.NET Core, including inside a MAUI app |
 | [Shiny.Net.HttpServer.Mediator](https://www.nuget.org/packages/Shiny.Net.HttpServer.Mediator) | Publishes Shiny.Mediator requests, commands and streams as endpoints generated at compile time. Generator included |
 | [Shiny.Net.HttpServer.DocumentDb](https://www.nuget.org/packages/Shiny.Net.HttpServer.DocumentDb) | Publishes a Shiny.DocumentDb type as a REST resource — list, by-id, count, CRUD, merge-patch and a live SSE tail |
-| [Shiny.Net.HttpServer.WebDav](https://www.nuget.org/packages/Shiny.Net.HttpServer.WebDav) | A WebDAV (RFC 4918) class 1 & 2 server over a directory — mount an app's storage in Finder, Windows Explorer or any WebDAV client |
+| [Shiny.Net.HttpServer.WebDav](https://www.nuget.org/packages/Shiny.Net.HttpServer.WebDav) | A WebDAV (RFC 4918) class 1 & 2 server over a directory — mount an app's storage in Finder, Windows Explorer or any WebDAV client, and open the same URL in a browser for a file manager with upload, rename and delete |
 | [Shiny.Net.HttpServer.Grpc](https://www.nuget.org/packages/Shiny.Net.HttpServer.Grpc) | gRPC and gRPC-Web — unary, streaming and bidirectional methods over the same HTTP/2 stack, with serialization you supply |
-| [Shiny.Net.HttpServer.CommandLine](https://www.nuget.org/packages/Shiny.Net.HttpServer.CommandLine) | A .NET tool — `shinyhttpserver` — that serves a directory over HTTP with the file browser, with basic auth, per-operation permissions, and a QR code in the banner so a phone can scan its way in — `--tunnel` swaps the LAN address for a public pinggy.io tunnel so the phone need not be on the same network |
+| [Shiny.Net.HttpServer.CommandLine](https://www.nuget.org/packages/Shiny.Net.HttpServer.CommandLine) | A .NET tool — `shinyhttpserver` — that serves a directory over WebDAV, so one address is both a browser file manager (browse, upload, rename, delete) and a drive Finder or Explorer can mount, with basic auth, per-operation permissions, and a QR code in the banner so a phone can scan its way in — `--tunnel` swaps the LAN address for a public pinggy.io tunnel so the phone need not be on the same network |
 
 ## Getting Started
 

samples/Sample.Api/Program.cs

@@ -216,7 +216,8 @@
 // Connect to Server) or Explorer (Map network drive) at http://localhost:8080/dav and the folder
 // opens as a drive — no client to write, and no client to install.
 //
-// A browser GET of the same URL shows a plain HTML index, which is the quickest way to see it
+// A browser GET of the same URL shows a file manager - listing, upload, new folder, rename, delete,
+// each offered only when the options above allow it - which is the quickest way to see the mount
 // working without mounting anything.
 app.MapWebDav("/dav", o =>
 {

samples/Sample.Maui/MauiProgram.cs

@@ -131,7 +131,9 @@ public static MauiApp CreateMauiApp()
                 // /files is a JSON API for a script; this is the protocol a desktop already speaks,
                 // so the phone's storage opens as a drive in Finder or Windows Explorer with nothing
                 // installed on either end. Point them at http://<device>:<port>/dav and sign in with
-                // the same account as everything else.
+                // the same account as everything else - or open that URL in a browser, where the
+                // same mount answers with a file manager: the phone's storage, uploaded to and
+                // deleted from, with no app on the other machine at all.
                 //
                 // Locking is left on, and that is not a detail: Finder and the Windows redirector
                 // both check for DAV class 2 at mount time and mount read-only without it, however

skills/shiny-httpserver/SKILL.md

@@ -97,6 +97,8 @@ triggers:
 - Shiny.Net.HttpServer.CommandLine
 - shinyhttpserver
 - serve a directory from the command line
+- file manager in a browser
+- mount a folder as a drive
 - QR code in the terminal
 - open a served directory on a phone
 - share a folder over the internet
@@ -208,6 +210,13 @@ dotnet tool install -g Shiny.Net.HttpServer.CommandLine  # `shinyhttpserver`, no
 `Shiny.Net.HttpServer.CommandLine` is a .NET tool, not something an app references: it serves a
 directory over HTTP from a terminal (`shinyhttpserver [path] -m read|create|update|delete|all
 -u user:password`). Reach for it when the ask is "serve this folder", not "add a server to my app".
+It mounts the directory over **WebDAV**, so one address is both a browser file manager (browse,
+upload, rename, delete — whatever `-m` allows) and a drive Finder, Explorer or a Linux file manager
+can mount. Scripting it is WebDAV: `GET`/`PUT`/`DELETE` as usual, `MKCOL` for a directory, `MOVE`
+for a rename, and `PROPFIND` with `Depth: 1` for a machine-readable listing — a `GET` on a directory
+returns the manager's HTML, not JSON. `-m` is enforced before the handler runs, across `MKCOL`,
+`COPY` and `MOVE` as well as `PUT`; a `MOVE` is judged by where it lands, and renaming needs
+`update` **and** `delete`.
 It listens on every interface by default and ends its banner with a scannable QR code of the LAN
 address plus the URL in full, so "get this folder onto my phone" is the tool answer, not code —
 `-a localhost` keeps it to the machine, `--no-qr` drops the code. Basic auth (`-u`) over plain HTTP
@@ -547,8 +556,9 @@ app.MapFileBrowser("/files", o => o.RootPath = FileSystem.AppDataDirectory).Requ
 
 `MapFileBrowser` is a JSON API you drive with curl or your own client. `MapWebDav` speaks the
 protocol the operating system already has a client for, so the folder mounts as a drive with no
-client code at all. Reach for it whenever the user says *mount*, *Finder*, *Explorer*, *map a
-network drive*, or *WebDAV*; reach for the file browser when they want an API.
+client code at all — and its browser `GET` is a working file manager. Reach for it whenever the user
+says *mount*, *Finder*, *Explorer*, *map a network drive*, *WebDAV*, or wants a **UI** over a
+directory; reach for the file browser when they want a JSON API to call from their own code.
 
 Tier 1: a mounted module of raw routes, twenty-two of them, mapped in one call.
 
@@ -571,9 +581,15 @@ app.MapWebDav("/dav", o =>
   small tree.
 - Dead properties (`PROPPATCH`) are held in memory. Assign `PropertyStore` to keep them across
   restarts.
-- A browser `GET` on a collection returns an HTML listing whose entries — and the link back to the
-  parent — are absolute, so the tree is walkable from a plain browser with or without a trailing
-  slash on the mount URL. `DirectoryBrowsing = false` turns it off.
+- A browser `GET` on a collection returns a **file manager**: listing with sizes and times,
+  breadcrumbs, drag-and-drop upload (`PUT`, folders walked and recreated), new folder (`MKCOL`),
+  rename (`MOVE`, `Overwrite: F`) and delete (`DELETE`), plus a download button per file. It offers
+  only what the options allow — read-only renders a listing with no buttons — and it is one
+  self-contained response with nothing fetched from outside. Entries and the link to the parent are
+  absolute, so the tree is walkable with or without a trailing slash on the mount URL.
+  `DirectoryBrowsing = false` turns the page off entirely (a browser `GET` then answers 405). This
+  is the same page `shinyhttpserver` serves — say "open the mount URL in a browser" when a user asks
+  for a UI over a directory; there is no other file-manager UI in this library.
 - The mount is excluded from the OpenAPI document — do not try to describe it.
 
 ## Realtime

src/Shiny.Net.HttpServer.CommandLine/Cli.cs

@@ -38,7 +38,7 @@ public static RootCommand Build(Func<ServeSettings, CancellationToken, Task<int>
 
         var prefixOpt = new Option<string>("--prefix")
         {
-            Description = "URL prefix the browser is mounted at.",
+            Description = "URL prefix the directory is mounted at.",
             DefaultValueFactory = _ => "/"
         };
 
@@ -117,7 +117,7 @@ public static RootCommand Build(Func<ServeSettings, CancellationToken, Task<int>
             Description = "Logs every request."
         };
 
-        var root = new RootCommand("Serves a directory over HTTP with the Shiny.Net.HttpServer file browser.")
+        var root = new RootCommand("Serves a directory over HTTP: a file manager in a browser, and a WebDAV drive in Finder or Explorer.")
         {
             pathArg,
             portOpt,

src/Shiny.Net.HttpServer.CommandLine/Permissions.cs

@@ -1,7 +1,7 @@
 namespace Shiny.Net.HttpServer.CommandLine;
 
 /// <summary>
-/// What the file browser is allowed to do. Read is always on - a server that cannot
+/// What the mount is allowed to do. Read is always on - a server that cannot
 /// be read from is not one worth starting.
 /// </summary>
 [Flags]

src/Shiny.Net.HttpServer.CommandLine/Runner.cs

@@ -5,9 +5,9 @@
 using System.Security.Cryptography.X509Certificates;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Shiny.Net.HttpServer.FileBrowser;
 using Shiny.Net.HttpServer.Security;
 using Shiny.Net.HttpServer.Ssh;
+using Shiny.Net.HttpServer.WebDav;
 
 namespace Shiny.Net.HttpServer.CommandLine;
 
@@ -78,26 +78,34 @@ public static async Task<int> RunAsync(ServeSettings settings, CancellationToken
         if (settings.Verbose)
             server.Use(LogRequestAsync);
 
-        // the browser has one write flag, so create/update only differ if something checks first
+        // the mount has one write flag, so create/update only differ if something checks first
         if (NeedsWriteGuard(settings.Permissions))
             server.Use(new WriteGuard(prefix, settings.RootPath, settings.Permissions));
 
-        var endpoints = server.MapFileBrowser(prefix, o =>
+        // WebDAV rather than the JSON file browser, because it is two things at once: the file
+        // manager a browser gets on GET, and a drive Finder, Explorer and the Linux file managers
+        // can mount at the same address - which is the shortest path from "a directory on this
+        // machine" to "a folder on that one".
+        var mount = server.MapWebDav(prefix, o =>
         {
             o.RootPath = settings.RootPath;
             o.AllowWrite = settings.Permissions.Has(Permissions.Create) || settings.Permissions.Has(Permissions.Update);
-            o.AllowCreateDirectories = settings.Permissions.Has(Permissions.Create);
             o.AllowDelete = settings.Permissions.Has(Permissions.Delete);
             o.ServeHiddenFiles = settings.ServeHidden;
             o.MaxUploadBytes = settings.MaxUploadBytes;
+            // The directory's own name, which is what the manager's breadcrumb and a mounted drive
+            // are labelled with. A root directory has no name, and there the mount's own default
+            // is the better answer than an empty label.
+            if (Path.GetFileName(Path.TrimEndingDirectorySeparator(settings.RootPath)) is { Length: > 0 } name)
+                o.DisplayName = name;
         });
 
         if (settings.AuthEnabled)
         {
             if (settings.AuthChangesOnly)
-                endpoints.RequireAuthorizationForChanges();
+                mount.RequireAuthorizationForChanges();
             else
-                endpoints.RequireAuthorization();
+                mount.RequireAuthorization();
         }
 
         // mounted anywhere else the site root is a 404, which is a worse answer than the listing
@@ -276,6 +284,7 @@ static void PrintBanner(ServeSettings settings, string prefix, string? tunnelUrl
             Line("Tunnel", TunnelUrl(tunnelUrl, prefix));
 
         Line("Operations", settings.Permissions.Describe());
+        Line("Mount", "WebDAV - Finder, Explorer and any WebDAV client can open the URL as a drive");
         Line(
             "Auth",
             settings.AuthEnabled

src/Shiny.Net.HttpServer.CommandLine/ServeSettings.cs

@@ -11,7 +11,7 @@ public sealed record ServeSettings
     public required IPAddress Address { get; init; }
     public required int Port { get; init; }
 
-    /// <summary>Where the browser is mounted - "/" serves the directory at the root of the site.</summary>
+    /// <summary>Where the directory is mounted - "/" serves it at the root of the site.</summary>
     public required string UrlPrefix { get; init; }
 
     public required Permissions Permissions { get; init; }

src/Shiny.Net.HttpServer.CommandLine/Shiny.Net.HttpServer.CommandLine.csproj

@@ -3,8 +3,8 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <RootNamespace>Shiny.Net.HttpServer.CommandLine</RootNamespace>
-    <Description>Serves a directory over HTTP from the command line with the Shiny.Net.HttpServer file browser: basic auth, per-operation permissions (read/create/update/delete) and optional TLS. Installs as a .NET tool.</Description>
-    <PackageTags>$(PackageTags) cli dotnet-tool filebrowser</PackageTags>
+    <Description>Serves a directory over HTTP from the command line: a browser file manager with upload, rename and delete, and the same address mounts as a WebDAV drive in Finder or Explorer. Basic auth, per-operation permissions (read/create/update/delete), optional TLS and a public tunnel. Installs as a .NET tool.</Description>
+    <PackageTags>$(PackageTags) cli dotnet-tool filebrowser filemanager webdav</PackageTags>
 
     <!-- The command is the product here, so the assembly carries the command's name — which means
          the package id has to be stated rather than inherited from it. -->
@@ -23,6 +23,7 @@
   <ItemGroup>
     <ProjectReference Include="../Shiny.Net.HttpServer/Shiny.Net.HttpServer.csproj" />
     <ProjectReference Include="../Shiny.Net.HttpServer.Ssh/Shiny.Net.HttpServer.Ssh.csproj" />
+    <ProjectReference Include="../Shiny.Net.HttpServer.WebDav/Shiny.Net.HttpServer.WebDav.csproj" />
   </ItemGroup>
 
   <ItemGroup>

src/Shiny.Net.HttpServer.CommandLine/WriteGuard.cs

@@ -1,13 +1,17 @@
-
 namespace Shiny.Net.HttpServer.CommandLine;
 
 
 /// <summary>
-/// Splits the file browser's single PUT into create and update.
+/// Splits the mount's single write switch into create and update.
+/// <para>
+/// WebDAV has one permission for writing, so create and update are the same <c>PUT</c> to it -
+/// and the same <c>MKCOL</c>, <c>COPY</c> and <c>MOVE</c>. Asking the file system whether the
+/// target already exists is the only thing that tells them apart, and it has to happen before the
+/// handler runs: after that the file is already written.
+/// </para>
 /// <para>
-/// The browser has one write switch, so create and update are the same route to it. Asking the
-/// file system whether the target already exists is the only thing that tells them apart, and it
-/// has to happen before the handler runs - after that the file is already written.
+/// Deleting needs none of this. It has a permission of its own on the mount, so it never reaches
+/// here.
 /// </para>
 /// </summary>
 public sealed class WriteGuard(string prefix, string rootPath, Permissions permissions) : IHttpMiddleware
@@ -32,32 +36,85 @@ await context.Response
     }
 
 
-    /// <summary>Null when this request is not a write, or when the path is one the browser will reject anyway.</summary>
+    /// <summary>Null when this request is not a write, or when the path is one the mount will reject anyway.</summary>
     Permissions? RequiredPermission(HttpRequest request)
     {
-        if (!String.Equals(request.Method, "PUT", StringComparison.OrdinalIgnoreCase))
-            return null;
+        // PROPPATCH and LOCK are left out on purpose. Neither changes a file's contents, and both
+        // are sent by Finder and by the Windows redirector around an ordinary upload - refusing
+        // them on a create-only server would break the upload the server does allow.
+        switch (request.Method.ToUpperInvariant())
+        {
+            case "PUT":
+                return this.ForTarget(request.Path);
+
+            // A collection either exists - in which case MKCOL is the mount's own 405 - or is about
+            // to, which is a create however the server is configured.
+            case "MKCOL":
+                return Permissions.Create;
 
-        if (!request.Path.StartsWith(this.pathPrefix, StringComparison.Ordinal))
+            // Both land bytes at the destination, and the destination is what decides which write
+            // it is. MOVE also removes the source, which the mount's delete permission gates.
+            case "COPY":
+            case "MOVE":
+                return request.Headers.GetFirst("Destination") is { Length: > 0 } destination
+                    ? this.ForTarget(DestinationPath(destination))
+                    : null;
+
+            default:
+                return null;
+        }
+    }
+
+
+    /// <summary>What writing to this path would be: replacing something, or making it.</summary>
+    Permissions? ForTarget(string path)
+    {
+        if (!path.StartsWith(this.pathPrefix, StringComparison.Ordinal))
             return null;
 
-        var relative = request.Path[this.pathPrefix.Length..];
+        var relative = path[this.pathPrefix.Length..];
         if (relative.Length == 0)
             return null;
 
-        // a trailing slash is the browser's directory create, never an overwrite
+        // a trailing slash names a collection, which is only ever created
         if (relative.EndsWith('/'))
             return Permissions.Create;
 
         var target = this.Resolve(relative);
         if (target == null)
             return null;
 
-        return File.Exists(target) ? Permissions.Update : Permissions.Create;
+        return File.Exists(target) || Directory.Exists(target) ? Permissions.Update : Permissions.Create;
+    }
+
+
+    /// <summary>
+    /// The path part of a <c>Destination</c>, which RFC 4918 allows to be a full URL. Percent
+    /// decoded, because that is the form the request path arrives in and the two are compared.
+    /// </summary>
+    static string DestinationPath(string destination)
+    {
+        var value = destination.Trim();
+
+        if (Uri.TryCreate(value, UriKind.Absolute, out var absolute))
+            value = absolute.AbsolutePath;
+
+        var query = value.IndexOfAny(['?', '#']);
+        if (query >= 0)
+            value = value[..query];
+
+        try
+        {
+            return Uri.UnescapeDataString(value);
+        }
+        catch (UriFormatException)
+        {
+            return value;
+        }
     }
 
 
-    /// <summary>The full path, or null when it escapes the root and the browser's own check will refuse it.</summary>
+    /// <summary>The full path, or null when it escapes the root and the mount's own check will refuse it.</summary>
     string? Resolve(string relative)
     {
         try