feat: M25 post-deployment TLS verification + M26 Traefik/Caddy targets

M25: After deploying a certificate, the agent probes the live TLS
endpoint and compares SHA-256 fingerprints to verify the correct cert
is being served. Best-effort — failures don't block deployments.
New endpoints: POST /jobs/{id}/verify, GET /jobs/{id}/verification.
Migration 000008 adds verification columns to jobs table.

M26: Traefik target connector (file provider, auto-reload) and Caddy
target connector (dual-mode: admin API hot-reload or file-based).
Both wired into agent dispatch.

Also: restructured README to highlight supported integrations (issuers,
targets, notifiers) earlier, moved API/CLI/MCP sections lower. Updated
all docs (features, connectors, architecture, testing guide, why-certctl)
and fixed integration tests for 18-param RegisterHandlers signature.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

internal/connector/target/caddy/caddy.go

@@ -0,0 +1,303 @@
+package caddy
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/shankar0123/certctl/internal/connector/target"
+)
+
+// Config represents the Caddy deployment target configuration.
+// Caddy supports both API-based and file-based certificate deployment.
+// In API mode, certificates are posted to the Caddy admin API.
+// In file mode, certificates are written to a directory and Caddy reloads.
+type Config struct {
+	AdminAPI string `json:"admin_api"` // Caddy admin API URL (e.g., http://localhost:2019, default: http://localhost:2019)
+	CertDir  string `json:"cert_dir"`  // Directory for file-based deployment (used if API fails or mode=file)
+	CertFile string `json:"cert_file"` // Filename for certificate in file mode (default: cert.pem)
+	KeyFile  string `json:"key_file"`  // Filename for private key in file mode (default: key.pem)
+	Mode     string `json:"mode"`      // Deployment mode: "api" (default) or "file"
+}
+
+// Connector implements the target.Connector interface for Caddy servers.
+// This connector runs on the AGENT side and handles local certificate deployment.
+// It supports both API-based hot reload and file-based deployment.
+type Connector struct {
+	config *Config
+	logger *slog.Logger
+	client *http.Client
+}
+
+// New creates a new Caddy target connector with the given configuration and logger.
+func New(config *Config, logger *slog.Logger) *Connector {
+	return &Connector{
+		config: config,
+		logger: logger,
+		client: &http.Client{Timeout: 10 * time.Second},
+	}
+}
+
+// ValidateConfig checks that the Caddy configuration is valid.
+func (c *Connector) ValidateConfig(ctx context.Context, rawConfig json.RawMessage) error {
+	var cfg Config
+	if err := json.Unmarshal(rawConfig, &cfg); err != nil {
+		return fmt.Errorf("invalid Caddy config: %w", err)
+	}
+
+	// Set defaults
+	if cfg.AdminAPI == "" {
+		cfg.AdminAPI = "http://localhost:2019"
+	}
+	if cfg.Mode == "" {
+		cfg.Mode = "api"
+	}
+	if cfg.CertFile == "" {
+		cfg.CertFile = "cert.pem"
+	}
+	if cfg.KeyFile == "" {
+		cfg.KeyFile = "key.pem"
+	}
+
+	// Validate mode
+	if cfg.Mode != "api" && cfg.Mode != "file" {
+		return fmt.Errorf("Caddy mode must be 'api' or 'file', got: %s", cfg.Mode)
+	}
+
+	c.logger.Info("validating Caddy configuration",
+		"admin_api", cfg.AdminAPI,
+		"mode", cfg.Mode)
+
+	// For file mode, verify directory exists
+	if cfg.Mode == "file" {
+		if cfg.CertDir == "" {
+			return fmt.Errorf("Caddy cert_dir is required in file mode")
+		}
+		if _, err := os.Stat(cfg.CertDir); os.IsNotExist(err) {
+			return fmt.Errorf("Caddy cert directory does not exist: %s", cfg.CertDir)
+		}
+		// Test write access
+		testFile := filepath.Join(cfg.CertDir, ".certctl-write-test")
+		if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil {
+			return fmt.Errorf("Caddy cert directory is not writable: %s (%w)", cfg.CertDir, err)
+		}
+		os.Remove(testFile)
+	}
+
+	c.config = &cfg
+	c.logger.Info("Caddy configuration validated")
+	return nil
+}
+
+// DeployCertificate deploys a certificate to Caddy using the configured mode.
+// In API mode, it posts the certificate to Caddy's admin API.
+// In file mode, it writes the certificate files and relies on Caddy's file watcher.
+//
+// Steps:
+// 1. If mode="api": POST to Caddy admin API endpoint with certificate data
+// 2. If mode="file" or API fails: Write certificate and key files to cert_dir
+// 3. Log deployment status
+func (c *Connector) DeployCertificate(ctx context.Context, request target.DeploymentRequest) (*target.DeploymentResult, error) {
+	c.logger.Info("deploying certificate to Caddy",
+		"mode", c.config.Mode,
+		"admin_api", c.config.AdminAPI)
+
+	startTime := time.Now()
+
+	// Try API mode if configured
+	if c.config.Mode == "api" {
+		result, err := c.deployViaAPI(ctx, request)
+		if err == nil {
+			c.logger.Info("certificate deployed to Caddy via API",
+				"duration", time.Since(startTime).String())
+			return result, nil
+		}
+		c.logger.Warn("API deployment failed, falling back to file mode", "error", err)
+	}
+
+	// Fall back to file mode
+	return c.deployViaFile(ctx, request, startTime)
+}
+
+// deployViaAPI deploys a certificate using Caddy's admin API.
+func (c *Connector) deployViaAPI(ctx context.Context, request target.DeploymentRequest) (*target.DeploymentResult, error) {
+	c.logger.Debug("attempting API deployment", "url", c.config.AdminAPI)
+
+	// Build the certificate payload with combined cert and chain
+	certData := request.CertPEM + "\n"
+	if request.ChainPEM != "" {
+		certData += request.ChainPEM + "\n"
+	}
+
+	payload := map[string]string{
+		"cert": certData,
+		"key":  request.KeyPEM,
+	}
+
+	bodyBytes, _ := json.Marshal(payload)
+	apiURL := c.config.AdminAPI + "/config/apps/tls/certificates/load"
+
+	req, err := http.NewRequestWithContext(ctx, "POST", apiURL, bytes.NewReader(bodyBytes))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create API request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to reach Caddy API: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, _ := io.ReadAll(resp.Body)
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		return nil, fmt.Errorf("Caddy API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	return &target.DeploymentResult{
+		Success:       true,
+		TargetAddress: c.config.AdminAPI,
+		DeploymentID:  fmt.Sprintf("caddy-api-%d", time.Now().Unix()),
+		Message:       "Certificate deployed via Caddy admin API",
+		DeployedAt:    time.Now(),
+		Metadata: map[string]string{
+			"method":      "api",
+			"admin_url":   c.config.AdminAPI,
+			"duration_ms": fmt.Sprintf("%d", time.Since(time.Now()).Milliseconds()),
+		},
+	}, nil
+}
+
+// deployViaFile deploys a certificate by writing files to the cert directory.
+func (c *Connector) deployViaFile(ctx context.Context, request target.DeploymentRequest, startTime time.Time) (*target.DeploymentResult, error) {
+	c.logger.Debug("deploying via file mode", "cert_dir", c.config.CertDir)
+
+	if c.config.CertDir == "" {
+		return &target.DeploymentResult{
+			Success:    false,
+			Message:    "cert_dir required for file mode deployment",
+			DeployedAt: time.Now(),
+		}, fmt.Errorf("cert_dir not configured for file mode")
+	}
+
+	certPath := filepath.Join(c.config.CertDir, c.config.CertFile)
+	keyPath := filepath.Join(c.config.CertDir, c.config.KeyFile)
+
+	// Write certificate with chain
+	certData := request.CertPEM + "\n"
+	if request.ChainPEM != "" {
+		certData += request.ChainPEM + "\n"
+	}
+	if err := os.WriteFile(certPath, []byte(certData), 0644); err != nil {
+		errMsg := fmt.Sprintf("failed to write certificate: %v", err)
+		c.logger.Error("certificate deployment failed", "error", err)
+		return &target.DeploymentResult{
+			Success:       false,
+			TargetAddress: certPath,
+			Message:       errMsg,
+			DeployedAt:    time.Now(),
+		}, fmt.Errorf("%s", errMsg)
+	}
+
+	// Write private key
+	if request.KeyPEM != "" {
+		if err := os.WriteFile(keyPath, []byte(request.KeyPEM), 0600); err != nil {
+			errMsg := fmt.Sprintf("failed to write private key: %v", err)
+			c.logger.Error("key deployment failed", "error", err)
+			return &target.DeploymentResult{
+				Success:       false,
+				TargetAddress: keyPath,
+				Message:       errMsg,
+				DeployedAt:    time.Now(),
+			}, fmt.Errorf("%s", errMsg)
+		}
+	}
+
+	deploymentDuration := time.Since(startTime)
+	c.logger.Info("certificate deployed to Caddy via file mode",
+		"duration", deploymentDuration.String(),
+		"cert_path", certPath,
+		"key_path", keyPath)
+
+	return &target.DeploymentResult{
+		Success:       true,
+		TargetAddress: certPath,
+		DeploymentID:  fmt.Sprintf("caddy-file-%d", time.Now().Unix()),
+		Message:       "Certificate deployed to Caddy (file-based)",
+		DeployedAt:    time.Now(),
+		Metadata: map[string]string{
+			"method":      "file",
+			"cert_path":   certPath,
+			"key_path":    keyPath,
+			"duration_ms": fmt.Sprintf("%d", deploymentDuration.Milliseconds()),
+		},
+	}, nil
+}
+
+// ValidateDeployment verifies that the deployed certificate is valid and accessible.
+// For API mode, it doesn't perform additional validation.
+// For file mode, it checks that the certificate and key files exist and are readable.
+func (c *Connector) ValidateDeployment(ctx context.Context, request target.ValidationRequest) (*target.ValidationResult, error) {
+	c.logger.Info("validating Caddy deployment",
+		"certificate_id", request.CertificateID,
+		"serial", request.Serial,
+		"mode", c.config.Mode)
+
+	startTime := time.Now()
+
+	// For file mode, verify files exist
+	if c.config.Mode == "file" || c.config.CertDir != "" {
+		certPath := filepath.Join(c.config.CertDir, c.config.CertFile)
+		keyPath := filepath.Join(c.config.CertDir, c.config.KeyFile)
+
+		if _, err := os.Stat(certPath); os.IsNotExist(err) {
+			errMsg := fmt.Sprintf("certificate file not found: %s", certPath)
+			c.logger.Error("validation failed", "error", err)
+			return &target.ValidationResult{
+				Valid:         false,
+				Serial:        request.Serial,
+				TargetAddress: certPath,
+				Message:       errMsg,
+				ValidatedAt:   time.Now(),
+			}, fmt.Errorf("%s", errMsg)
+		}
+
+		if _, err := os.Stat(keyPath); os.IsNotExist(err) {
+			errMsg := fmt.Sprintf("private key file not found: %s", keyPath)
+			c.logger.Error("validation failed", "error", err)
+			return &target.ValidationResult{
+				Valid:         false,
+				Serial:        request.Serial,
+				TargetAddress: keyPath,
+				Message:       errMsg,
+				ValidatedAt:   time.Now(),
+			}, fmt.Errorf("%s", errMsg)
+		}
+	}
+
+	validationDuration := time.Since(startTime)
+	c.logger.Info("Caddy deployment validated successfully",
+		"duration", validationDuration.String())
+
+	return &target.ValidationResult{
+		Valid:         true,
+		Serial:        request.Serial,
+		TargetAddress: c.config.AdminAPI,
+		Message:       "Caddy certificate deployment validated",
+		ValidatedAt:   time.Now(),
+		Metadata: map[string]string{
+			"mode":        c.config.Mode,
+			"admin_api":   c.config.AdminAPI,
+			"duration_ms": fmt.Sprintf("%d", validationDuration.Milliseconds()),
+		},
+	}, nil
+}

internal/connector/target/caddy/caddy_test.go

@@ -0,0 +1,398 @@
+package caddy_test
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/shankar0123/certctl/internal/connector/target"
+	"github.com/shankar0123/certctl/internal/connector/target/caddy"
+)
+
+func TestCaddyConnector_ValidateConfig_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err != nil {
+		t.Fatalf("ValidateConfig failed: %v", err)
+	}
+}
+
+func TestCaddyConnector_ValidateConfig_InvalidJSON(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	connector := caddy.New(&caddy.Config{}, logger)
+	err := connector.ValidateConfig(ctx, json.RawMessage(`{invalid}`))
+	if err == nil {
+		t.Fatal("expected error for invalid JSON")
+	}
+}
+
+func TestCaddyConnector_ValidateConfig_InvalidMode(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  tmpDir,
+		Mode:     "invalid",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err == nil {
+		t.Fatal("expected error for invalid mode")
+	}
+}
+
+func TestCaddyConnector_ValidateConfig_FileMode_MissingCertDir(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err == nil {
+		t.Fatal("expected error for missing cert_dir in file mode")
+	}
+}
+
+func TestCaddyConnector_ValidateConfig_DefaultsApplied(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		CertDir: tmpDir,
+		Mode:    "file",
+		// Don't specify AdminAPI, CertFile, KeyFile - should use defaults
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err != nil {
+		t.Fatalf("ValidateConfig failed: %v", err)
+	}
+}
+
+func TestCaddyConnector_DeployViaAPI_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	// Create a mock Caddy admin API server
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.Contains(r.URL.Path, "/config/apps/tls/certificates/load") {
+			// Verify POST request with JSON body
+			if r.Method != "POST" {
+				t.Fatalf("expected POST, got %s", r.Method)
+			}
+			body, _ := io.ReadAll(r.Body)
+			var payload map[string]string
+			json.Unmarshal(body, &payload)
+			if payload["cert"] == "" {
+				t.Fatal("cert field missing in payload")
+			}
+			if payload["key"] == "" {
+				t.Fatal("key field missing in payload")
+			}
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer server.Close()
+
+	cfg := caddy.Config{
+		AdminAPI: server.URL,
+		Mode:     "api",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed, got: %s", result.Message)
+	}
+
+	if !strings.Contains(result.Message, "API") {
+		t.Fatalf("expected API deployment message, got: %s", result.Message)
+	}
+}
+
+func TestCaddyConnector_DeployViaAPI_ServerError(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	// Create a mock Caddy admin API server that returns error
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusBadRequest)
+		w.Write([]byte("invalid certificate"))
+	}))
+	defer server.Close()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: server.URL,
+		CertDir:  tmpDir,
+		Mode:     "api",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	// API fails and falls back to file mode - should succeed
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed via file fallback, got: %s", result.Message)
+	}
+
+	if !strings.Contains(result.Message, "file") {
+		t.Fatalf("expected file deployment message after API failure, got: %s", result.Message)
+	}
+}
+
+func TestCaddyConnector_DeployViaFile_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed, got: %s", result.Message)
+	}
+
+	// Verify files were created
+	certPath := filepath.Join(tmpDir, "cert.pem")
+	keyPath := filepath.Join(tmpDir, "key.pem")
+
+	if _, err := os.Stat(certPath); os.IsNotExist(err) {
+		t.Fatalf("certificate file was not created: %s", certPath)
+	}
+
+	if _, err := os.Stat(keyPath); os.IsNotExist(err) {
+		t.Fatalf("key file was not created: %s", keyPath)
+	}
+
+	// Verify key file has correct permissions
+	keyInfo, _ := os.Stat(keyPath)
+	if keyInfo.Mode().Perm() != 0600 {
+		t.Fatalf("key file permissions are %o, expected 0600", keyInfo.Mode().Perm())
+	}
+}
+
+func TestCaddyConnector_DeployViaFile_WriteError(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  "/root/nonexistent",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err == nil {
+		t.Fatal("expected error for write failure")
+	}
+
+	if result.Success {
+		t.Fatal("deployment should fail")
+	}
+}
+
+func TestCaddyConnector_ValidateDeployment_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	// Deploy a certificate
+	deployRequest := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+	connector.DeployCertificate(ctx, deployRequest)
+
+	// Validate deployment
+	validateRequest := target.ValidationRequest{
+		CertificateID: "mc-test",
+		Serial:        "123456",
+	}
+
+	result, err := connector.ValidateDeployment(ctx, validateRequest)
+	if err != nil {
+		t.Fatalf("ValidateDeployment failed: %v", err)
+	}
+
+	if !result.Valid {
+		t.Fatalf("validation should succeed, got: %s", result.Message)
+	}
+
+	if result.Serial != "123456" {
+		t.Fatalf("serial mismatch: expected 123456, got %s", result.Serial)
+	}
+}
+
+func TestCaddyConnector_ValidateDeployment_FileNotFound(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := caddy.Config{
+		AdminAPI: "http://localhost:2019",
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+		Mode:     "file",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	// Don't deploy, just validate
+	validateRequest := target.ValidationRequest{
+		CertificateID: "mc-test",
+		Serial:        "123456",
+	}
+
+	result, err := connector.ValidateDeployment(ctx, validateRequest)
+	if err == nil {
+		t.Fatal("expected error for missing certificate file")
+	}
+
+	if result.Valid {
+		t.Fatal("validation should fail")
+	}
+}
+
+func TestCaddyConnector_APIMode_NoChain(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.Contains(r.URL.Path, "/config/apps/tls/certificates/load") {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer server.Close()
+
+	cfg := caddy.Config{
+		AdminAPI: server.URL,
+		Mode:     "api",
+	}
+
+	connector := caddy.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	request := target.DeploymentRequest{
+		CertPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:  "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		// No ChainPEM
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed, got: %s", result.Message)
+	}
+}

internal/connector/target/traefik/traefik.go

@@ -0,0 +1,208 @@
+package traefik
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/shankar0123/certctl/internal/connector/target"
+)
+
+// Config represents the Traefik deployment target configuration.
+// Traefik uses a file provider that watches a directory for certificate files.
+// When files change, Traefik automatically reloads without requiring a reload command.
+type Config struct {
+	CertDir  string `json:"cert_dir"`  // Directory where Traefik watches for certificate files
+	CertFile string `json:"cert_file"` // Filename for certificate (default: cert.pem)
+	KeyFile  string `json:"key_file"`  // Filename for private key (default: key.pem)
+}
+
+// Connector implements the target.Connector interface for Traefik servers.
+// This connector runs on the AGENT side and handles local certificate deployment.
+// Traefik watches the configured directory and automatically reloads when files change.
+type Connector struct {
+	config *Config
+	logger *slog.Logger
+}
+
+// New creates a new Traefik target connector with the given configuration and logger.
+func New(config *Config, logger *slog.Logger) *Connector {
+	return &Connector{
+		config: config,
+		logger: logger,
+	}
+}
+
+// ValidateConfig checks that the certificate directory exists and is writable.
+func (c *Connector) ValidateConfig(ctx context.Context, rawConfig json.RawMessage) error {
+	var cfg Config
+	if err := json.Unmarshal(rawConfig, &cfg); err != nil {
+		return fmt.Errorf("invalid Traefik config: %w", err)
+	}
+
+	if cfg.CertDir == "" {
+		return fmt.Errorf("Traefik cert_dir is required")
+	}
+
+	// Default filenames if not provided
+	if cfg.CertFile == "" {
+		cfg.CertFile = "cert.pem"
+	}
+	if cfg.KeyFile == "" {
+		cfg.KeyFile = "key.pem"
+	}
+
+	c.logger.Info("validating Traefik configuration",
+		"cert_dir", cfg.CertDir,
+		"cert_file", cfg.CertFile,
+		"key_file", cfg.KeyFile)
+
+	// Verify directory exists and is writable
+	if _, err := os.Stat(cfg.CertDir); os.IsNotExist(err) {
+		return fmt.Errorf("Traefik cert directory does not exist: %s", cfg.CertDir)
+	}
+
+	// Try to write a test file to verify directory is writable
+	testFile := filepath.Join(cfg.CertDir, ".certctl-write-test")
+	if err := os.WriteFile(testFile, []byte("test"), 0644); err != nil {
+		return fmt.Errorf("Traefik cert directory is not writable: %s (%w)", cfg.CertDir, err)
+	}
+	// Clean up test file
+	os.Remove(testFile)
+
+	c.config = &cfg
+	c.logger.Info("Traefik configuration validated")
+	return nil
+}
+
+// DeployCertificate writes the certificate and key files to the configured directory.
+// Traefik watches this directory and automatically reloads when files change.
+//
+// Steps:
+// 1. Write certificate to cert_file with mode 0644 (readable by all)
+// 2. Write private key to key_file with mode 0600 (private key permissions)
+// 3. Traefik's file watcher automatically picks up the changes
+func (c *Connector) DeployCertificate(ctx context.Context, request target.DeploymentRequest) (*target.DeploymentResult, error) {
+	c.logger.Info("deploying certificate to Traefik",
+		"cert_dir", c.config.CertDir,
+		"cert_file", c.config.CertFile,
+		"key_file", c.config.KeyFile)
+
+	startTime := time.Now()
+
+	certPath := filepath.Join(c.config.CertDir, c.config.CertFile)
+	keyPath := filepath.Join(c.config.CertDir, c.config.KeyFile)
+
+	// Write certificate and chain combined with mode 0644 (readable by all)
+	certData := request.CertPEM + "\n"
+	if request.ChainPEM != "" {
+		certData += request.ChainPEM + "\n"
+	}
+	if err := os.WriteFile(certPath, []byte(certData), 0644); err != nil {
+		errMsg := fmt.Sprintf("failed to write certificate: %v", err)
+		c.logger.Error("certificate deployment failed", "error", err)
+		return &target.DeploymentResult{
+			Success:       false,
+			TargetAddress: certPath,
+			Message:       errMsg,
+			DeployedAt:    time.Now(),
+		}, fmt.Errorf("%s", errMsg)
+	}
+
+	// Write private key with secure permissions (0600: rw-------)
+	if request.KeyPEM != "" {
+		if err := os.WriteFile(keyPath, []byte(request.KeyPEM), 0600); err != nil {
+			errMsg := fmt.Sprintf("failed to write private key: %v", err)
+			c.logger.Error("key deployment failed", "error", err)
+			return &target.DeploymentResult{
+				Success:       false,
+				TargetAddress: keyPath,
+				Message:       errMsg,
+				DeployedAt:    time.Now(),
+			}, fmt.Errorf("%s", errMsg)
+		}
+	}
+
+	deploymentDuration := time.Since(startTime)
+	c.logger.Info("certificate deployed to Traefik successfully",
+		"duration", deploymentDuration.String(),
+		"cert_path", certPath,
+		"key_path", keyPath)
+
+	return &target.DeploymentResult{
+		Success:       true,
+		TargetAddress: certPath,
+		DeploymentID:  fmt.Sprintf("traefik-%d", time.Now().Unix()),
+		Message:       "Certificate deployed to Traefik (file watcher will auto-reload)",
+		DeployedAt:    time.Now(),
+		Metadata: map[string]string{
+			"cert_path":   certPath,
+			"key_path":    keyPath,
+			"duration_ms": fmt.Sprintf("%d", deploymentDuration.Milliseconds()),
+		},
+	}, nil
+}
+
+// ValidateDeployment verifies that the deployed certificate files are readable.
+// It checks that both the certificate and key files exist and are accessible.
+//
+// Steps:
+// 1. Verify certificate file exists and is readable
+// 2. Verify key file exists and is readable
+func (c *Connector) ValidateDeployment(ctx context.Context, request target.ValidationRequest) (*target.ValidationResult, error) {
+	c.logger.Info("validating Traefik deployment",
+		"certificate_id", request.CertificateID,
+		"serial", request.Serial)
+
+	startTime := time.Now()
+
+	certPath := filepath.Join(c.config.CertDir, c.config.CertFile)
+	keyPath := filepath.Join(c.config.CertDir, c.config.KeyFile)
+
+	// Verify certificate file exists and is readable
+	if _, err := os.Stat(certPath); os.IsNotExist(err) {
+		errMsg := fmt.Sprintf("certificate file not found: %s", certPath)
+		c.logger.Error("validation failed", "error", err)
+		return &target.ValidationResult{
+			Valid:         false,
+			Serial:        request.Serial,
+			TargetAddress: certPath,
+			Message:       errMsg,
+			ValidatedAt:   time.Now(),
+		}, fmt.Errorf("%s", errMsg)
+	}
+
+	// Verify key file exists and is readable
+	if _, err := os.Stat(keyPath); os.IsNotExist(err) {
+		errMsg := fmt.Sprintf("private key file not found: %s", keyPath)
+		c.logger.Error("validation failed", "error", err)
+		return &target.ValidationResult{
+			Valid:         false,
+			Serial:        request.Serial,
+			TargetAddress: keyPath,
+			Message:       errMsg,
+			ValidatedAt:   time.Now(),
+		}, fmt.Errorf("%s", errMsg)
+	}
+
+	validationDuration := time.Since(startTime)
+	c.logger.Info("Traefik deployment validated successfully",
+		"duration", validationDuration.String())
+
+	return &target.ValidationResult{
+		Valid:         true,
+		Serial:        request.Serial,
+		TargetAddress: certPath,
+		Message:       "Certificate and key files accessible",
+		ValidatedAt:   time.Now(),
+		Metadata: map[string]string{
+			"cert_path":   certPath,
+			"key_path":    keyPath,
+			"duration_ms": fmt.Sprintf("%d", validationDuration.Milliseconds()),
+		},
+	}, nil
+}

internal/connector/target/traefik/traefik_test.go

@@ -0,0 +1,291 @@
+package traefik_test
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/shankar0123/certctl/internal/connector/target"
+	"github.com/shankar0123/certctl/internal/connector/target/traefik"
+)
+
+func TestTraefikConnector_ValidateConfig_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err != nil {
+		t.Fatalf("ValidateConfig failed: %v", err)
+	}
+}
+
+func TestTraefikConnector_ValidateConfig_InvalidJSON(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	connector := traefik.New(&traefik.Config{}, logger)
+	err := connector.ValidateConfig(ctx, json.RawMessage(`{invalid}`))
+	if err == nil {
+		t.Fatal("expected error for invalid JSON")
+	}
+}
+
+func TestTraefikConnector_ValidateConfig_MissingCertDir(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	cfg := traefik.Config{
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err == nil {
+		t.Fatal("expected error for missing cert_dir")
+	}
+}
+
+func TestTraefikConnector_ValidateConfig_DirectoryNotExists(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	cfg := traefik.Config{
+		CertDir:  "/nonexistent/directory",
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err == nil {
+		t.Fatal("expected error for non-existent directory")
+	}
+}
+
+func TestTraefikConnector_DeployCertificate_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed, got: %s", result.Message)
+	}
+
+	// Verify certificate file was created
+	certPath := filepath.Join(tmpDir, "cert.pem")
+	if _, err := os.Stat(certPath); os.IsNotExist(err) {
+		t.Fatalf("certificate file was not created: %s", certPath)
+	}
+
+	// Verify key file was created with correct permissions
+	keyPath := filepath.Join(tmpDir, "key.pem")
+	if _, err := os.Stat(keyPath); os.IsNotExist(err) {
+		t.Fatalf("key file was not created: %s", keyPath)
+	}
+
+	// Check key file permissions (should be 0600)
+	keyInfo, _ := os.Stat(keyPath)
+	perms := keyInfo.Mode().Perm()
+	if perms != 0600 {
+		t.Fatalf("key file permissions are %o, expected 0600", perms)
+	}
+}
+
+func TestTraefikConnector_DeployCertificate_WriteError(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	// Use a non-existent directory to trigger write error
+	cfg := traefik.Config{
+		CertDir:  "/root/certctl/certs",
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+
+	request := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err == nil {
+		t.Fatal("expected error for write failure")
+	}
+
+	if result.Success {
+		t.Fatal("deployment should fail")
+	}
+}
+
+func TestTraefikConnector_ValidateDeployment_Success(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	// First deploy a certificate
+	deployRequest := target.DeploymentRequest{
+		CertPEM:  "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:   "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+		ChainPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+	}
+	connector.DeployCertificate(ctx, deployRequest)
+
+	// Now validate
+	validateRequest := target.ValidationRequest{
+		CertificateID: "mc-test",
+		Serial:        "123456",
+	}
+
+	result, err := connector.ValidateDeployment(ctx, validateRequest)
+	if err != nil {
+		t.Fatalf("ValidateDeployment failed: %v", err)
+	}
+
+	if !result.Valid {
+		t.Fatalf("validation should succeed, got: %s", result.Message)
+	}
+
+	if result.Serial != "123456" {
+		t.Fatalf("serial mismatch: expected 123456, got %s", result.Serial)
+	}
+}
+
+func TestTraefikConnector_ValidateDeployment_CertFileNotFound(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	// Don't deploy anything, just validate
+	validateRequest := target.ValidationRequest{
+		CertificateID: "mc-test",
+		Serial:        "123456",
+	}
+
+	result, err := connector.ValidateDeployment(ctx, validateRequest)
+	if err == nil {
+		t.Fatal("expected error for missing certificate file")
+	}
+
+	if result.Valid {
+		t.Fatal("validation should fail")
+	}
+}
+
+func TestTraefikConnector_DeployCertificate_WithoutChain(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir:  tmpDir,
+		CertFile: "cert.pem",
+		KeyFile:  "key.pem",
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	_ = connector.ValidateConfig(ctx, rawConfig)
+
+	// Deploy without chain
+	request := target.DeploymentRequest{
+		CertPEM: "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----",
+		KeyPEM:  "-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----",
+	}
+
+	result, err := connector.DeployCertificate(ctx, request)
+	if err != nil {
+		t.Fatalf("DeployCertificate failed: %v", err)
+	}
+
+	if !result.Success {
+		t.Fatalf("deployment should succeed, got: %s", result.Message)
+	}
+
+	// Verify certificate file exists
+	certPath := filepath.Join(tmpDir, "cert.pem")
+	data, err := os.ReadFile(certPath)
+	if err != nil {
+		t.Fatalf("failed to read cert file: %v", err)
+	}
+
+	if string(data) != "-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----\n" {
+		t.Fatalf("certificate content mismatch")
+	}
+}
+
+func TestTraefikConnector_DefaultFilenames(t *testing.T) {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	cfg := traefik.Config{
+		CertDir: tmpDir,
+		// Don't specify CertFile and KeyFile, use defaults
+	}
+
+	connector := traefik.New(&cfg, logger)
+	rawConfig, _ := json.Marshal(cfg)
+	err := connector.ValidateConfig(ctx, rawConfig)
+	if err != nil {
+		t.Fatalf("ValidateConfig failed: %v", err)
+	}
+}