fix(caddy): resolve startup errors by querying root config

Instead of querying `/apps/http/servers` directly, which causes Caddy to log 'invalid traversal path' or 400 Bad Request errors when the paths don't exist in a fresh configuration, the API client now queries the root config (`/`) and safely handles the empty state. This ensures a cleaner startup log output and avoids unnecessary patch requests.

Includes a minor fix for the UI tour targeting the filter buttons.

Author: sudocarlos

webui/cmd/webui/web/static/js/spa.bundle.js

@@ -57,7 +57,7 @@ <h1 class="h4 mb-1">Relays & Proxies</h1>
               <use href="/static/vendor/bootstrap-icons/bootstrap-icons.svg#bi-question-circle"></use>
             </svg>
           </button>
-          <div class="btn-group" role="group" aria-label="Type filter">
+          <div class="btn-group" role="group" aria-label="Type filter" id="filter-relay-buttons">
             <input type="checkbox" class="btn-check" id="filter-relay" autocomplete="off" checked />
             <label class="btn btn-outline-primary btn-sm" for="filter-relay" data-bs-toggle="tooltip"
               data-bs-placement="bottom" title="TCP relays served by socat">

webui/cmd/webui/web/templates/index.html

@@ -1083,7 +1083,7 @@
       fallbackText: "The Autostart toggle appears on each proxy/relay card. It lets services start automatically on boot.",
     },
     {
-      target: "#filter-relay",
+      target: "#filter-relay-buttons",
       title: "Filter Items",
       description: "Use these toggles to show or hide TCP relays and HTTPS proxies in the list below.",
     },

webui/frontend/src/index.js

@@ -34,9 +34,9 @@ const (
 
 // APIClient provides methods to interact with Caddy's admin API
 type APIClient struct {
-	BaseURL         string
-	HTTPClient      *http.Client
-	MaxLogBodySize  int
+	BaseURL        string
+	HTTPClient     *http.Client
+	MaxLogBodySize int
 }
 
 // NewAPIClient creates a new Caddy API client
@@ -113,7 +113,13 @@ func (c *APIClient) doRequestWithHeaders(method, path string, body interface{})
 	}
 
 	if resp.StatusCode >= 400 {
-		logger.Error("caddy", "Caddy API error %d for %s %s: %s", resp.StatusCode, method, url, string(respBody))
+		if method == http.MethodGet && (resp.StatusCode == http.StatusNotFound ||
+			(resp.StatusCode == http.StatusBadRequest && strings.Contains(string(respBody), "invalid traversal path"))) {
+			// Expected during checks when paths don't exist yet
+			logger.Debug("caddy", "Path not found (expected during checks): %d for %s %s: %s", resp.StatusCode, method, url, string(respBody))
+		} else {
+			logger.Error("caddy", "Caddy API error %d for %s %s: %s", resp.StatusCode, method, url, string(respBody))
+		}
 		return nil, nil, &HTTPError{StatusCode: resp.StatusCode, Body: string(respBody)}
 	}
 

webui/internal/caddy/api_client.go

@@ -121,21 +121,25 @@ func (m *Manager) InitializeAutostart() error {
 	skipped := 0
 	for _, proxy := range proxies {
 		if proxy.Autostart {
+			// Always sync state to Caddy API to ensure the route exists after a container restart
+			proxy.Enabled = true
+			if err := m.UpdateProxy(proxy); err != nil {
+				log.Printf("Warning: failed to autostart proxy %s (ID: %s): %v", proxy.Hostname, proxy.ID, err)
+				skipped++
+				continue
+			}
+			started++
+			log.Printf("Autostarted proxy %s (ID: %s)", proxy.Hostname, proxy.ID)
+		} else {
+			// Check if we need to sync disabled state (if it was previously thought to be enabled)
 			if proxy.Enabled {
-				// Already enabled, count it
-				started++
-				log.Printf("Proxy %s (ID: %s) has autostart enabled and is already active", proxy.Hostname, proxy.ID)
-			} else {
-				// Enable it now
-				proxy.Enabled = true
+				proxy.Enabled = false
 				if err := m.UpdateProxy(proxy); err != nil {
-					log.Printf("Warning: failed to autostart proxy %s (ID: %s): %v", proxy.Hostname, proxy.ID, err)
-					continue
+					log.Printf("Warning: failed to sync disabled state for proxy %s (ID: %s): %v", proxy.Hostname, proxy.ID, err)
+				} else {
+					log.Printf("Disabled non-autostart proxy %s (ID: %s)", proxy.Hostname, proxy.ID)
 				}
-				started++
-				log.Printf("Autostarted proxy %s (ID: %s)", proxy.Hostname, proxy.ID)
 			}
-		} else {
 			skipped++
 		}
 	}

webui/internal/caddy/manager.go

@@ -0,0 +1,116 @@
+package caddy
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/sudocarlos/tailrelay/internal/config"
+)
+
+func TestManager_InitializeAutostart(t *testing.T) {
+	var requests []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		reqStr := r.Method + " " + r.URL.Path
+		requests = append(requests, reqStr)
+		// Return 404 for listServers and ensureHTTPServersPath to mimic empty Caddy
+		if r.Method == http.MethodGet && (r.URL.Path == "/config/apps/http/servers" || r.URL.Path == "/config" || r.URL.Path == "/config/") {
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(`{"error":"loading config path \"/\": path not found"}`))
+			return
+		}
+
+		// For everything else (PUT, PATCH, DELETE), return OK
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{}`)) // provide a valid json response body
+	}))
+	defer srv.Close()
+
+	dir := t.TempDir()
+	serverMapPath := dir + "/servers.json"
+
+	manager := NewManager(srv.URL, serverMapPath)
+
+	// Add proxy 1: Autostart true, initially Enabled false
+	_, err := manager.AddProxy(config.CaddyProxy{
+		ID:        "proxy-1",
+		Hostname:  "test1.com",
+		Port:      8081,
+		Target:    "localhost:9091",
+		Enabled:   false,
+		Autostart: true,
+	})
+	if err != nil {
+		t.Fatalf("Failed to add proxy-1: %v", err)
+	}
+
+	// Add proxy 2: Autostart false, initially Enabled true
+	_, err = manager.AddProxy(config.CaddyProxy{
+		ID:        "proxy-2",
+		Hostname:  "test2.com",
+		Port:      8082,
+		Target:    "localhost:9092",
+		Enabled:   true,
+		Autostart: false,
+	})
+	if err != nil {
+		t.Fatalf("Failed to add proxy-2: %v", err)
+	}
+
+	// Add proxy 3: Autostart true, initially Enabled true
+	_, err = manager.AddProxy(config.CaddyProxy{
+		ID:        "proxy-3",
+		Hostname:  "test3.com",
+		Port:      8083,
+		Target:    "localhost:9093",
+		Enabled:   true,
+		Autostart: true,
+	})
+	if err != nil {
+		t.Fatalf("Failed to add proxy-3: %v", err)
+	}
+
+	// Clear request log from the initial AddProxy calls
+	requests = []string{}
+
+	// Run InitializeAutostart
+	if err := manager.InitializeAutostart(); err != nil {
+		t.Fatalf("InitializeAutostart failed: %v", err)
+	}
+
+	// Verify resulting metadata state
+	p1, _ := manager.GetProxy("proxy-1")
+	if !p1.Enabled {
+		t.Errorf("Proxy 1 should be enabled because Autostart is true")
+	}
+
+	p2, _ := manager.GetProxy("proxy-2")
+	if p2.Enabled {
+		t.Errorf("Proxy 2 should be disabled because Autostart is false, overriding its previous state")
+	}
+
+	p3, _ := manager.GetProxy("proxy-3")
+	if !p3.Enabled {
+		t.Errorf("Proxy 3 should be enabled because Autostart is true")
+	}
+
+	// Verify that the mock server received the expected requests
+	t.Logf("Recorded requests: %v", requests)
+	if len(requests) == 0 {
+		t.Errorf("Expected Caddy API requests during InitializeAutostart, but got none")
+	}
+
+	// proxy-1 and proxy-3 should result in PUT or PATCH (create or update route) requests
+	updateReqs := 0
+	for _, req := range requests {
+		if (len(req) > 3) && (req[:3] == "PUT" || req[:5] == "PATCH") && len(req) > 30 && req[len(req)-4:] != "fig/" {
+			// Count requests like "PUT /config/apps/http/servers/srv..." or "PATCH /config/apps/http/servers/srv..."
+			// But exclude "PATCH /config/"
+			updateReqs++
+		}
+	}
+
+	if updateReqs < 2 {
+		t.Errorf("Expected at least 2 PUT/PATCH requests for autostart proxies, got %d", updateReqs)
+	}
+}

webui/internal/caddy/manager_test.go

@@ -612,27 +612,52 @@ func extractIDFromLocation(location string) (string, error) {
 }
 
 func (pm *ProxyManager) ensureHTTPServersPath() error {
-	_, err := pm.client.GetConfig("/apps/http/servers")
-	if err == nil {
-		// Path already exists, nothing to do
-		return nil
+	// Instead of querying /apps/http/servers which triggers a 400 error in Caddy's logs
+	// if the path doesn't exist, we query the root config and check locally.
+	data, err := pm.client.GetConfig("/")
+	if err != nil {
+		var httpErr *HTTPError
+		if errors.As(err, &httpErr) && httpErr.StatusCode == http.StatusNotFound {
+			// Root config doesn't exist, it's empty
+			data = []byte(`{}`)
+		} else {
+			return fmt.Errorf("failed to get root config: %w", err)
+		}
 	}
 
-	// Check if this is the "invalid traversal path" or 404 error
-	var httpErr *HTTPError
-	if errors.As(err, &httpErr) {
-		if httpErr.StatusCode == http.StatusNotFound ||
-			(httpErr.StatusCode == http.StatusBadRequest && strings.Contains(httpErr.Body, "invalid traversal path")) {
-			// We can safely PATCH the root config to ensure the path exists without destroying data
-			initPayload := map[string]interface{}{
-				"apps": map[string]interface{}{
-					"http": map[string]interface{}{},
-				},
-			}
-			return pm.client.PatchConfig("/", initPayload)
+	dataStr := strings.TrimSpace(string(data))
+	if len(dataStr) == 0 || dataStr == "null" {
+		data = []byte(`{}`)
+	}
+
+	var root map[string]interface{}
+	if err := json.Unmarshal(data, &root); err != nil {
+		return fmt.Errorf("failed to parse root config: %w", err)
+	}
+
+	apps, ok := root["apps"].(map[string]interface{})
+	if !ok {
+		apps = make(map[string]interface{})
+	}
+
+	httpApp, ok := apps["http"].(map[string]interface{})
+	if !ok {
+		// Path doesn't exist, safely create it
+		initPayload := map[string]interface{}{
+			"apps": map[string]interface{}{
+				"http": map[string]interface{}{},
+			},
 		}
+		return pm.client.PatchConfig("/", initPayload)
 	}
-	return err
+
+	if _, ok := httpApp["servers"]; !ok {
+		// servers key doesn't exist yet but http does, nothing to patch since
+		// adding a server will automatically create the servers map.
+		return nil
+	}
+
+	return nil
 }
 
 // InitializeServer ensures the HTTP server exists in Caddy config
@@ -664,28 +689,54 @@ func (pm *ProxyManager) InitializeServer(listenAddrs []string) error {
 }
 
 func (pm *ProxyManager) listServers() (map[string]*HTTPServer, error) {
-	data, err := pm.client.GetConfig("/apps/http/servers")
+	// Query root config instead of /apps/http/servers to avoid 400 errors
+	// when the path doesn't exist yet
+	data, err := pm.client.GetConfig("/")
 	if err != nil {
-		// When Caddy config is empty ({}), the servers path doesn't exist yet and
-		// Caddy returns a 404 (or 400 Bad Request with "invalid traversal path").
-		// Treat this as an empty server list so callers can proceed normally.
 		var httpErr *HTTPError
-		if errors.As(err, &httpErr) {
-			if httpErr.StatusCode == http.StatusNotFound ||
-				(httpErr.StatusCode == http.StatusBadRequest && strings.Contains(httpErr.Body, "invalid traversal path")) {
-				return map[string]*HTTPServer{}, nil
-			}
+		if errors.As(err, &httpErr) && httpErr.StatusCode == http.StatusNotFound {
+			// Root config doesn't exist, treat as empty server list
+			return map[string]*HTTPServer{}, nil
 		}
-		return nil, err
+		return nil, fmt.Errorf("failed to get root config: %w", err)
+	}
+
+	dataStr := strings.TrimSpace(string(data))
+	if len(dataStr) == 0 || dataStr == "null" {
+		return map[string]*HTTPServer{}, nil
+	}
+
+	var root map[string]interface{}
+	if err := json.Unmarshal(data, &root); err != nil {
+		return nil, fmt.Errorf("failed to parse root config: %w", err)
+	}
+
+	apps, ok := root["apps"].(map[string]interface{})
+	if !ok {
+		return map[string]*HTTPServer{}, nil
+	}
+
+	httpApp, ok := apps["http"].(map[string]interface{})
+	if !ok {
+		return map[string]*HTTPServer{}, nil
+	}
+
+	serversRaw, ok := httpApp["servers"]
+	if !ok || serversRaw == nil {
+		return map[string]*HTTPServer{}, nil
+	}
+
+	// Marshaling just the servers part to unmarshal into our struct map
+	serversData, err := json.Marshal(serversRaw)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal servers data: %w", err)
 	}
 
 	var servers map[string]*HTTPServer
-	if err := json.Unmarshal(data, &servers); err != nil {
+	if err := json.Unmarshal(serversData, &servers); err != nil {
 		return nil, fmt.Errorf("unmarshal servers: %w", err)
 	}
 
-	// json.Unmarshal of a JSON null yields nil; normalize to a non-nil empty map
-	// so callers can iterate safely.
 	if servers == nil {
 		servers = map[string]*HTTPServer{}
 	}
@@ -720,15 +771,13 @@ func (pm *ProxyManager) getServerNameForProxy(proxy config.CaddyProxy) (string,
 
 // serverExistsInCaddy checks if a server name actually exists in Caddy's configuration
 func (pm *ProxyManager) serverExistsInCaddy(serverName string) bool {
-	path := fmt.Sprintf("/apps/http/servers/%s", serverName)
-	data, err := pm.client.GetConfig(path)
+	// Use listServers to avoid 400 errors when checking paths
+	servers, err := pm.listServers()
 	if err != nil {
 		return false
 	}
-	// Caddy returns "null" for non-existent paths
-	dataStr := strings.TrimSpace(string(data))
-	exists := len(dataStr) > 0 && dataStr != "null"
-	logger.Debug("caddy", "Checking if server %s exists in Caddy: %v (data: %s)", serverName, exists, dataStr)
+	_, exists := servers[serverName]
+	logger.Debug("caddy", "Checking if server %s exists in Caddy: %v", serverName, exists)
 	return exists
 }
 

webui/internal/caddy/proxy_manager.go

@@ -15,11 +15,11 @@ func newTestProxyManager(t *testing.T, apiURL string) *ProxyManager {
 }
 
 // TestListServers_EmptyCaddyConfig verifies that listServers returns an empty map
-// (not an error) when Caddy's config is {} and the /apps/http/servers path returns 404.
+// (not an error) when Caddy's config is {} and the root path returns 404.
 func TestListServers_EmptyCaddyConfig(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
-		w.Write([]byte(`{"error":"loading config path \"/apps/http/servers\": path not found"}`))
+		w.Write([]byte(`{"error":"loading config path \"/\": path not found"}`))
 	}))
 	defer srv.Close()
 
@@ -76,7 +76,7 @@ func TestListServers_EmptyObjectResponse(t *testing.T) {
 func TestAllocateServerName_EmptyCaddyConfig(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
-		w.Write([]byte(`{"error":"path not found"}`))
+		w.Write([]byte(`{"error":"loading config path \"/\": path not found"}`))
 	}))
 	defer srv.Close()