refactor: delegate supervisor logic to Caddy.Supervisor module

Move the supervisor implementation from Caddy module to a dedicated
Caddy.Supervisor module for better separation of concerns. The Caddy
module now acts as a clean facade that delegates to Caddy.Supervisor,
while maintaining full backward compatibility with existing code.

Changes:
- Create new Caddy.Supervisor module containing supervisor implementation
- Update Caddy module to delegate start_link, restart_server, and stop
- Update Caddy.ConfigProvider and Caddy.Admin to call Caddy.Supervisor.restart_server
- Caddy.Application continues to use {Caddy, args} as entry point

All existing APIs remain unchanged and fully backward compatible.

Author: GSMLG-BOT

lib/caddy.ex

@@ -49,24 +49,18 @@ defmodule Caddy do
   ```
 
   """
-  require Logger
 
-  use Supervisor
+  @doc """
+  Start the Caddy supervisor as part of a supervision tree.
+  """
+  @spec start_link(Keyword.t()) :: :ignore | {:error, any()} | {:ok, pid()}
+  defdelegate start_link(args), to: Caddy.Supervisor
 
   @doc """
   Restart Caddy Server
   """
   @spec restart_server :: {:ok, pid()} | {:ok, :undefined} | {:error, term()}
-  def restart_server do
-    case Supervisor.restart_child(__MODULE__, Caddy.Server) do
-      {:error, :running} ->
-        Supervisor.terminate_child(__MODULE__, Caddy.Server)
-        Supervisor.restart_child(__MODULE__, Caddy.Server)
-
-      out ->
-        out
-    end
-  end
+  defdelegate restart_server, to: Caddy.Supervisor
 
   @doc """
   Manually Start Caddy Server.
@@ -83,34 +77,13 @@ defmodule Caddy do
     start_link(caddy_bin: caddy_bin)
   end
 
+  @doc """
+  Stop Caddy Server
+  """
   @spec stop(term()) :: :ok
-  def stop(reason \\ :normal) do
-    Supervisor.stop(__MODULE__, reason)
-  end
-
-  @spec start_link(Keyword.t()) :: :ignore | {:error, any()} | {:ok, pid()}
-  def start_link(args) do
-    Supervisor.start_link(__MODULE__, args, name: __MODULE__)
-  end
-
-  @impl true
-  @spec init(any()) ::
-          {:ok,
-           {Supervisor.sup_flags(),
-            [Supervisor.child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}
-  def init(args) do
-    children = [
-      {Caddy.ConfigProvider, [args]},
-      Caddy.Logger,
-      Caddy.Server
-      # Caddy.Admin
-    ]
-
-    opts = [strategy: :rest_for_one, name: __MODULE__]
-
-    Supervisor.init(children, opts)
-  end
+  defdelegate stop(reason \\ :normal), to: Caddy.Supervisor
 
+  # Configuration management functions delegated to ConfigProvider
   defdelegate set_bin(bin_path), to: Caddy.ConfigProvider
   defdelegate set_bin!(bin_path), to: Caddy.ConfigProvider
   defdelegate set_global(global), to: Caddy.ConfigProvider

lib/caddy/admin.ex

@@ -32,6 +32,6 @@ defmodule Caddy.Admin do
   rescue
     error ->
       Logger.error("Caddy Admin: check_caddy_server failed #{inspect(error)}")
-      Caddy.restart_server()
+      Caddy.Supervisor.restart_server()
   end
 end

lib/caddy/config_provider.ex

@@ -75,7 +75,7 @@ defmodule Caddy.ConfigProvider do
   @spec set_bin!(binary()) :: :ok | {:error, term()}
   def set_bin!(caddy_bin) do
     Agent.update(__MODULE__, &Map.put(&1, :bin, caddy_bin))
-    Caddy.restart_server()
+    Caddy.Supervisor.restart_server()
   end
 
   @doc "Set global configuration"

lib/caddy/supervisor.ex

@@ -0,0 +1,74 @@
+defmodule Caddy.Supervisor do
+  @moduledoc """
+  Main supervisor for the Caddy subsystem.
+
+  Manages the Caddy configuration, logging, and server processes
+  using a rest_for_one strategy to ensure proper restart ordering.
+
+  ## Supervision Tree
+
+  - `Caddy.ConfigProvider` - Agent for configuration management
+  - `Caddy.Logger` - Logging subsystem with buffer and storage
+  - `Caddy.Server` - GenServer managing the Caddy binary process
+
+  The rest_for_one strategy ensures that if the ConfigProvider crashes,
+  all subsequent children are restarted. If the Logger crashes, only
+  the Server is restarted.
+  """
+
+  use Supervisor
+
+  @doc """
+  Start the Caddy supervisor.
+
+  ## Options
+
+  - `:caddy_bin` - Path to the Caddy binary (optional)
+  """
+  @spec start_link(Keyword.t()) :: :ignore | {:error, any()} | {:ok, pid()}
+  def start_link(args) do
+    Supervisor.start_link(__MODULE__, args, name: __MODULE__)
+  end
+
+  @impl true
+  @spec init(any()) ::
+          {:ok,
+           {Supervisor.sup_flags(),
+            [Supervisor.child_spec() | (old_erlang_child_spec :: :supervisor.child_spec())]}}
+  def init(args) do
+    children = [
+      {Caddy.ConfigProvider, [args]},
+      Caddy.Logger,
+      Caddy.Server
+    ]
+
+    opts = [strategy: :rest_for_one, name: __MODULE__]
+
+    Supervisor.init(children, opts)
+  end
+
+  @doc """
+  Restart the Caddy Server child process.
+
+  Returns `{:ok, pid()}` on successful restart, or `{:error, term()}` on failure.
+  """
+  @spec restart_server :: {:ok, pid()} | {:ok, :undefined} | {:error, term()}
+  def restart_server do
+    case Supervisor.restart_child(__MODULE__, Caddy.Server) do
+      {:error, :running} ->
+        Supervisor.terminate_child(__MODULE__, Caddy.Server)
+        Supervisor.restart_child(__MODULE__, Caddy.Server)
+
+      out ->
+        out
+    end
+  end
+
+  @doc """
+  Stop the Caddy supervisor.
+  """
+  @spec stop(term()) :: :ok
+  def stop(reason \\ :normal) do
+    Supervisor.stop(__MODULE__, reason)
+  end
+end