Update reload logic and add documentation

* Added documentation
* Implement equality checks for Server (ServerEntry and ServerExecutionContext)
* Added 'UpdateTools' to MCPClientAccessor (ClientManager)
* Update 'reload' logic for MCP servers to handle tool only changes etc.
*

Author: peteski22

docs/configuration.md

@@ -24,11 +24,12 @@ You can provide this path in multiple ways:
 [[servers]]
   name = "fetch"
   package = "uvx::mcp-server-fetch@2025.4.7"
+  tools = ["fetch"]
 
 [[servers]]
   name = "time"
-  package = "uvx::mcp-server-time@0.6.2"
-  tools = ["get_current_time"]
+  package = "uvx::mcp-server-time@2025.8.4"
+  tools = ["get_current_time", "convert_time"]
 ```
 
 ---
@@ -65,6 +66,150 @@ Options:
 
 ---
 
+## Hot Reload
+
+The `mcpd` daemon supports hot-reloading of MCP server configurations without requiring a full restart. This allows you to add, remove, or modify server configurations while keeping the daemon running.
+
+Hot reload processes both:
+
+- **Server configuration** (`--config-file`) e.g. `.mcpd.toml`
+- **Execution context** (`--runtime-file`) e.g. `secrets.dev.toml`
+
+### SIGHUP Signal
+
+Send a `SIGHUP` signal to the running daemon process to trigger a configuration reload:
+
+```bash
+# Find the daemon process ID
+ps aux | grep mcpd
+
+# Send reload signal (replace PID with actual process ID)
+kill -HUP <PID>
+```
+
+### Reload Behavior
+
+During a hot reload, the daemon intelligently categorizes changes and responds accordingly:
+
+| Change Type           | Action   | Description                                                                                                                                                       |
+|-----------------------|----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Unchanged servers     | Preserve | Servers with identical configurations keep their existing connections, tools, and health status                                                                   |
+| Removed servers       | Stop     | Servers no longer in the config file are gracefully shut down                                                                                                     |
+| New servers           | Start    | Newly added servers are initialized and connected                                                                                                                 |
+| 'Tools-Only' changes  | Update   | When only the `tools` change, the daemon updates the allowed tools without restarting the server process                                                          |
+| Configuration changes | Restart  | Servers with other configuration changes (package version, environment variables, arguments, execution context, etc.) are stopped and restarted with new settings |
+
+### Example: 'Tools-Only' Update
+
+Consider this server configuration:
+
+```toml
+[[servers]]
+  name = "github"
+  package = "uvx::modelcontextprotocol/github-server@1.2.3"
+  tools = ["create_repository", "get_repository"]
+```
+
+If you modify only the tools list:
+
+```toml
+[[servers]]
+  name = "github" 
+  package = "uvx::modelcontextprotocol/github-server@1.2.3"
+  tools = ["create_repository", "get_repository", "list_repositories"] # Additional tools
+```
+
+The daemon will:
+
+1. Detect that only the `tools` array changed
+2. Update the allowed tools list in-place
+3. Keep the existing server process and connections intact
+4. Log a message that tools for a server were updated (including the server name and list of tools)
+
+### Example: Package Version Update
+
+If you change the package version:
+
+```toml
+[[servers]]
+  name = "github"
+  package = "uvx::modelcontextprotocol/github-server@1.3.0"  # Version changed
+  tools = ["create_repository", "get_repository", "list_repositories"]
+```
+
+The daemon will:
+
+1. Detect configuration changes beyond just tools
+2. Gracefully stop the existing server
+3. Start a new server with the updated configuration
+4. Log a message that the server is being restarted (including the server name)
+
+### Execution Context and Environment Variables
+
+!!! warning "Environment Variable Visibility"
+    The `mcpd` process can only see environment variables that existed when it started.
+
+    If you export new environment variables in your shell after starting `mcpd`, you must restart the daemon for those variables to become available for shell expansion.
+
+When the execution context file is reloaded, shell expansion of environment variables (`${VAR}` syntax) 
+occurs using the environment available to the running `mcpd` process when it was started.
+
+#### What Works During Hot Reload
+
+Direct values are applied immediately:
+
+```toml
+[servers.jira]
+  args = ["--confluence-token=test123", "--confluence-url=http://jira-test.mozilla.ai"]
+[servers.mcp-discord.env]
+  DISCORD_TOKEN = "qwerty123!1one"
+```
+
+Shell expansion of existing environment variables works:
+
+```toml
+[servers.myserver]
+  args = ["--home=${HOME}", "--user=${USER}"]  # These expand to current values
+[servers.myserver.env]
+  CONFIG_PATH = "${HOME}/.config/myapp"  # Expands using mcpd's environment
+```
+
+#### What Requires an `mcpd` Restart
+
+New environment variables added to the system after `mcpd` started won't be visible:
+
+```toml
+[servers.myserver]
+  args = ["--token=${NEW_TOKEN}"]  # NEW_TOKEN added after mcpd started
+[servers.myserver.env]
+  API_KEY = "${NEWLY_EXPORTED_VAR}"  # Won't expand until mcpd restarts
+```
+
+### Limitations
+
+
+Hot reload does **NOT** apply to:
+
+- Daemon-level config settings (timeouts, CORS, etc.)
+- New environment variables added to the system
+
+Both require `mcpd` to be restarted for changes to take effect
+
+### Error Handling
+
+The reload process maintains strict consistency - any error causes the daemon to exit:
+
+- **Configuration errors**: Invalid configuration files or loading failures cause the daemon to exit
+- **Validation errors**: Invalid server configurations cause the daemon to exit  
+- **Server operation failures**: Any failure to start, stop, or restart a server causes the daemon to exit
+
+This ensures the daemon never runs in an inconsistent or partially-failed state, matching the behavior during initial startup where any server failure prevents the daemon from running.
+
+!!! warning "Reload Failures"
+    Unlike some systems that allow partial reloads, `mcpd` exits on any reload error to prevent inconsistent state. You'll need to fix the configuration and restart the daemon.
+
+---
+
 ## Configuration Export
 
 The `mcpd config export` command generates portable configuration files for deployment across different environments. It creates template variables using the naming pattern `MCPD__{SERVER_NAME}__{VARIABLE_NAME}`.
@@ -83,7 +228,7 @@ Environment variables and command-line arguments are both converted to template
 
 In most cases, this is intentional, the same configuration value is being used in different ways. The collision results in a single template variable that can be used for both the environment variable and command-line argument.
 
-#### Example collision
+#### Example Collision
 
 ```toml
 [[servers]]

internal/api/servers_test.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/mark3labs/mcp-go/client"
@@ -48,6 +49,14 @@ func (m *mockMCPClientAccessor) List() []string {
 	return names
 }
 
+func (m *mockMCPClientAccessor) UpdateTools(name string, tools []string) error {
+	if _, ok := m.clients[name]; !ok {
+		return fmt.Errorf("server '%s' not found", name)
+	}
+	m.tools[name] = tools
+	return nil
+}
+
 func (m *mockMCPClientAccessor) Remove(name string) {
 	delete(m.clients, name)
 	delete(m.tools, name)

internal/config/types.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"slices"
 	"strings"
 
 	"github.com/mozilla-ai/mcpd/v2/internal/context"
@@ -118,29 +119,24 @@ type serverKey struct {
 	Package string // NOTE: without version
 }
 
-func (e *ServerEntry) PackageVersion() string {
+// argEntry represents a parsed command line argument.
+type argEntry struct {
+	key   string
+	value string
+}
+
+func (s *ServerEntry) PackageVersion() string {
 	versionDelim := "@"
-	pkg := stripPrefix(e.Package)
+	pkg := stripPrefix(s.Package)
 
 	if idx := strings.LastIndex(pkg, versionDelim); idx != -1 {
 		return pkg[idx+len(versionDelim):]
 	}
 	return pkg
 }
 
-func (e *ServerEntry) PackageName() string {
-	return stripPrefix(stripVersion(e.Package))
-}
-
-// argEntry represents a parsed command line argument.
-type argEntry struct {
-	key   string
-	value string
-}
-
-// hasValue is used to determine if an argEntry is a bool flag or contains a value.
-func (e *argEntry) hasValue() bool {
-	return strings.TrimSpace(e.value) != ""
+func (s *ServerEntry) PackageName() string {
+	return stripPrefix(stripVersion(s.Package))
 }
 
 func (e *argEntry) String() string {
@@ -152,13 +148,102 @@ func (e *argEntry) String() string {
 
 // RequiredArguments returns all required CLI arguments, including positional, value-based and boolean flags.
 // NOTE: The order of these arguments matters, so positional arguments appear first.
-func (e *ServerEntry) RequiredArguments() []string {
-	out := make([]string, 0, len(e.RequiredPositionalArgs)+len(e.RequiredValueArgs)+len(e.RequiredBoolArgs))
+func (s *ServerEntry) RequiredArguments() []string {
+	out := make([]string, 0, len(s.RequiredPositionalArgs)+len(s.RequiredValueArgs)+len(s.RequiredBoolArgs))
 
 	// Add positional args first.
-	out = append(out, e.RequiredPositionalArgs...)
-	out = append(out, e.RequiredValueArgs...)
-	out = append(out, e.RequiredBoolArgs...)
+	out = append(out, s.RequiredPositionalArgs...)
+	out = append(out, s.RequiredValueArgs...)
+	out = append(out, s.RequiredBoolArgs...)
 
 	return out
 }
+
+// Equal compares two ServerEntry instances for equality.
+// Returns true if all fields are equal.
+// RequiredPositionalArgs order matters (positional), all other slices are order-independent.
+func (s *ServerEntry) Equal(other *ServerEntry) bool {
+	if other == nil {
+		return false
+	}
+
+	// Compare basic fields.
+	if s.Name != other.Name {
+		return false
+	}
+
+	if s.Package != other.Package {
+		return false
+	}
+
+	// RequiredPositionalArgs order matters since they're positional.
+	if !slices.Equal(s.RequiredPositionalArgs, other.RequiredPositionalArgs) {
+		return false
+	}
+
+	// All other slices are flags, so order doesn't matter.
+	// NOTE: We are assuming that tools are always already normalized, ready for comparison.
+	if !equalStringSlicesUnordered(s.Tools, other.Tools) {
+		return false
+	}
+
+	if !equalStringSlicesUnordered(s.RequiredEnvVars, other.RequiredEnvVars) {
+		return false
+	}
+
+	if !equalStringSlicesUnordered(s.RequiredValueArgs, other.RequiredValueArgs) {
+		return false
+	}
+
+	if !equalStringSlicesUnordered(s.RequiredBoolArgs, other.RequiredBoolArgs) {
+		return false
+	}
+
+	return true
+}
+
+// EqualExceptTools compares this server with another and returns true if only the Tools field differs.
+// All other configuration fields must be identical for this to return true.
+func (s *ServerEntry) EqualExceptTools(other *ServerEntry) bool {
+	if other == nil {
+		return false
+	}
+
+	// Create copies with identical Tools to compare everything else.
+	a := s
+	b := other
+
+	// Temporarily set tools to be identical for comparison.
+	bTools := b.Tools
+	b.Tools = a.Tools
+
+	// If everything else is equal, then only tools differ.
+	equalIgnoringTools := a.Equal(b)
+
+	// Restore original tools.
+	b.Tools = bTools
+
+	// Return true only if everything else is equal AND tools actually differ.
+	// NOTE: We are assuming that tools are always already normalized, ready for comparison.
+	return equalIgnoringTools && !equalStringSlicesUnordered(s.Tools, other.Tools)
+}
+
+// equalStringSlicesUnordered compares two string slices for equality, ignoring order.
+func equalStringSlicesUnordered(a []string, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	x := slices.Clone(a)
+	y := slices.Clone(b)
+
+	slices.Sort(x)
+	slices.Sort(y)
+
+	return slices.Equal(x, y)
+}
+
+// hasValue is used to determine if an argEntry is a bool flag or contains a value.
+func (e *argEntry) hasValue() bool {
+	return strings.TrimSpace(e.value) != ""
+}