feat(cli): implement doctor, windows-setup, windows-cleanup commands

Author: alysnnix

cmd/devproxy/main.go

@@ -4,14 +4,20 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"log/slog"
 	"net"
 	"net/http"
 	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
 
 	"github.com/alysnnix/devproxy/internal/daemon"
 	"github.com/alysnnix/devproxy/internal/ipman"
 	"github.com/alysnnix/devproxy/internal/state"
+	"github.com/alysnnix/devproxy/internal/windows"
+	"github.com/miekg/dns"
 )
 
 func main() {
@@ -29,11 +35,11 @@ func main() {
 	case "cleanup":
 		runCleanup()
 	case "doctor":
-		fmt.Println("devproxy doctor — not yet implemented")
+		runDoctor()
 	case "windows-setup":
-		fmt.Println("devproxy windows-setup — not yet implemented")
+		runWindowsSetup()
 	case "windows-cleanup":
-		fmt.Println("devproxy windows-cleanup — not yet implemented")
+		runWindowsCleanup()
 	default:
 		fmt.Fprintf(os.Stderr, "unknown command: %s\n", os.Args[1])
 		os.Exit(1)
@@ -134,3 +140,219 @@ func unixClient(sockPath string) *http.Client {
 		},
 	}
 }
+
+// dockerSocketPaths lists the Docker socket paths to try, in order.
+var dockerSocketPaths = []string{
+	"/var/run/docker.sock",
+	"/mnt/wsl/docker-desktop/shared-sockets/guest-services/docker.sock",
+}
+
+// checkDockerSocket verifies that the Docker socket is accessible.
+func checkDockerSocket() error {
+	for _, p := range dockerSocketPaths {
+		if _, err := os.Stat(p); err == nil {
+			return nil
+		}
+	}
+	return fmt.Errorf("Docker socket not found (tried %s)", strings.Join(dockerSocketPaths, ", "))
+}
+
+// checkDNS queries devproxy-health.localhost on 127.0.53.53:53.
+func checkDNS() error {
+	m := new(dns.Msg)
+	m.SetQuestion("devproxy-health.localhost.", dns.TypeA)
+
+	c := new(dns.Client)
+	resp, _, err := c.Exchange(m, "127.0.53.53:53")
+	if err != nil {
+		return fmt.Errorf("DNS query failed: %w", err)
+	}
+	if resp.Rcode != dns.RcodeSuccess {
+		return fmt.Errorf("DNS query returned rcode %d (%s)", resp.Rcode, dns.RcodeToString[resp.Rcode])
+	}
+	return nil
+}
+
+// daemonSocketPath is the default path to the devproxy daemon socket.
+var daemonSocketPath = "/run/devproxy/devproxy.sock"
+
+// checkDaemonAPI connects to the daemon Unix socket and GETs /health.
+func checkDaemonAPI() error {
+	client := unixClient(daemonSocketPath)
+	resp, err := client.Get("http://devproxy/health")
+	if err != nil {
+		return fmt.Errorf("cannot reach daemon: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("daemon unhealthy (status %d): %s", resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+// checkResolved runs resolvectl to verify systemd-resolved can resolve
+// devproxy-health.localhost.
+func checkResolved() error {
+	cmd := exec.Command("resolvectl", "query", "devproxy-health.localhost")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("resolvectl failed: %s", strings.TrimSpace(string(output)))
+	}
+	return nil
+}
+
+func runDoctor() {
+	type check struct {
+		name string
+		fn   func() error
+	}
+
+	checks := []check{
+		{"Docker socket", checkDockerSocket},
+		{"DNS server (127.0.53.53)", checkDNS},
+		{"Daemon API", checkDaemonAPI},
+		{"systemd-resolved", checkResolved},
+	}
+
+	allPassed := true
+	dnsDirectOK := false
+
+	for _, c := range checks {
+		err := c.fn()
+		if err != nil {
+			fmt.Printf("  [FAIL] %s: %v\n", c.name, err)
+			allPassed = false
+		} else {
+			fmt.Printf("  [ OK ] %s\n", c.name)
+			if c.name == "DNS server (127.0.53.53)" {
+				dnsDirectOK = true
+			}
+		}
+	}
+
+	// If DNS direct query works but systemd-resolved fails, give a hint.
+	if dnsDirectOK {
+		// Check if resolved was the one that failed
+		if err := checkResolved(); err != nil {
+			fmt.Println()
+			fmt.Println("  Hint: DNS server is running but systemd-resolved cannot resolve")
+			fmt.Println("        devproxy domains. Check that /etc/systemd/resolved.conf.d/")
+			fmt.Println("        has the correct devproxy DNS delegation configuration.")
+		}
+	}
+
+	fmt.Println()
+	if allPassed {
+		fmt.Println("All checks passed.")
+	} else {
+		fmt.Println("Some checks failed. See above for details.")
+		os.Exit(1)
+	}
+}
+
+// getWSLIP returns the WSL2 eth0 IPv4 address.
+func getWSLIP() (string, error) {
+	iface, err := net.InterfaceByName("eth0")
+	if err != nil {
+		// Fallback: parse hostname -I output
+		out, cmdErr := exec.Command("hostname", "-I").Output()
+		if cmdErr != nil {
+			return "", fmt.Errorf("cannot detect WSL2 IP: eth0 not found and hostname -I failed")
+		}
+		fields := strings.Fields(string(out))
+		if len(fields) == 0 {
+			return "", fmt.Errorf("hostname -I returned no addresses")
+		}
+		return fields[0], nil
+	}
+
+	addrs, err := iface.Addrs()
+	if err != nil {
+		return "", fmt.Errorf("cannot get eth0 addresses: %w", err)
+	}
+	for _, addr := range addrs {
+		if ipNet, ok := addr.(*net.IPNet); ok && ipNet.IP.To4() != nil {
+			return ipNet.IP.String(), nil
+		}
+	}
+	return "", fmt.Errorf("no IPv4 address found on eth0")
+}
+
+func runWindowsSetup() {
+	// Connect to daemon to get project list.
+	client := unixClient(daemonSocketPath)
+	resp, err := client.Get("http://devproxy/status")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: daemon not running? %v\n", err)
+		os.Exit(1)
+	}
+	defer resp.Body.Close()
+
+	var status struct {
+		Projects []struct {
+			Name  string              `json:"name"`
+			IP    string              `json:"ip"`
+			Ports []state.PortMapping `json:"ports"`
+		} `json:"projects"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
+		fmt.Fprintf(os.Stderr, "error decoding status: %v\n", err)
+		os.Exit(1)
+	}
+
+	if len(status.Projects) == 0 {
+		fmt.Fprintln(os.Stderr, "No active projects. Start some containers first.")
+		os.Exit(1)
+	}
+
+	// Detect WSL2 IP.
+	wslIP, err := getWSLIP()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Convert to state.Project for GenerateSetupScript.
+	projects := make([]*state.Project, len(status.Projects))
+	for i, p := range status.Projects {
+		projects[i] = &state.Project{
+			Name:  p.Name,
+			IP:    p.IP,
+			Ports: p.Ports,
+		}
+	}
+
+	script := windows.GenerateSetupScript(projects, wslIP)
+
+	// Check for --execute flag.
+	executeFlag := false
+	for _, arg := range os.Args[2:] {
+		if arg == "--execute" {
+			executeFlag = true
+		}
+	}
+
+	if executeFlag {
+		// Write to temp file and print instructions.
+		tmpDir := os.TempDir()
+		tmpFile := filepath.Join(tmpDir, "devproxy-setup.ps1")
+		if err := os.WriteFile(tmpFile, []byte(script), 0644); err != nil {
+			fmt.Fprintf(os.Stderr, "error writing temp file: %v\n", err)
+			os.Exit(1)
+		}
+
+		fmt.Printf("Script written to: %s\n", tmpFile)
+		fmt.Println()
+		fmt.Println("Run in an elevated PowerShell on Windows:")
+		fmt.Printf("  powershell.exe -ExecutionPolicy Bypass -File %s\n", tmpFile)
+	} else {
+		fmt.Print(script)
+	}
+}
+
+func runWindowsCleanup() {
+	script := windows.GenerateCleanupScript()
+	fmt.Print(script)
+}