refactor: eliminate uncors wrapper, wire server directly through cli

CLAUDE.md

@@ -79,7 +79,7 @@ UNCORS follows a clean layered architecture with middleware composition:
 
 **`internal/infra`** - Infrastructure services
 - HTTP client with connection pooling and proxy support
-- Logger setup (logs to stderr or file with debug flag)
+- Logger setup (logs to stderr or file based on UNCORS_LOGGING env var)
 - TLS certificate generation and handling
 
 **`internal/tui`** - Terminal UI and logging
@@ -142,8 +142,7 @@ Key test flags:
 
 **Key Config Options**
 - `proxy`: Upstream proxy URL (optional)
-- `interactive`: Enable TUI mode
-- `debug`: Enable debug logging
+- `interactive`: Enable TUI mode (default: true)
 - `port`: Listen port (default: 3000)
 - `mappings`: Array of request mappings (from/to hosts)
 
@@ -177,7 +176,7 @@ Key test flags:
 4. Update CONTRIBUTING.md if user-facing
 
 ### Debugging
-- Enable debug logs: `./uncors -d` (writes to `uncors.log`)
+- Enable logging: Set `UNCORS_LOGGING=/path/to/logfile` environment variable
 - Run single test: `go test -run TestName ./internal/handler/proxy/`
 - Race detector: Already enabled in `make test` and `make test-cover`
 - Integration tests: `make test-integration` (slower, real network)

internal/cli/generate_certs.go

@@ -0,0 +1,28 @@
+package cli
+
+import (
+	"errors"
+
+	"github.com/evg4b/uncors/internal/di"
+	"github.com/spf13/pflag"
+)
+
+const GenerateCertsCmd = "generate-certs"
+
+func GenerateCerts(container *di.Container) error {
+	cmd := container.GenerateCertsCommand()
+
+	flags := pflag.NewFlagSet(GenerateCertsCmd, pflag.ContinueOnError)
+	cmd.DefineFlags(flags, container.Version())
+
+	err := flags.Parse(container.Args())
+	if err != nil {
+		if !errors.Is(err, pflag.ErrHelp) {
+			return err
+		}
+
+		return nil
+	}
+
+	return cmd.Execute()
+}

internal/cli/generate_certs_test.go

@@ -0,0 +1,29 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/evg4b/uncors/internal/cli"
+	"github.com/evg4b/uncors/internal/di"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGenerateCerts(t *testing.T) {
+	t.Run("returns error for unknown flag", func(t *testing.T) {
+		err := cli.GenerateCerts(di.NewContainer(di.WithArgs([]string{"--unknown-flag"})))
+		require.Error(t, err)
+	})
+
+	t.Run("generates CA certificate with valid args", func(t *testing.T) {
+		// Point HOME to a temp dir so certs go there, not ~/.config/uncors.
+		t.Setenv("HOME", t.TempDir())
+
+		err := cli.GenerateCerts(di.NewContainer(di.WithArgs([]string{"--validity-days=7"})))
+		require.NoError(t, err)
+	})
+
+	t.Run("returns nil for --help flag", func(t *testing.T) {
+		err := cli.GenerateCerts(di.NewContainer(di.WithArgs([]string{"--help"})))
+		require.NoError(t, err)
+	})
+}

internal/cli/run_ineractive.go

@@ -0,0 +1,33 @@
+package cli
+
+import (
+	"context"
+
+	tea "charm.land/bubbletea/v2"
+	"github.com/evg4b/uncors/internal/config"
+	"github.com/evg4b/uncors/internal/di"
+	uncor "github.com/evg4b/uncors/internal/uncors_app"
+)
+
+func runIneractive(
+	ctx context.Context,
+	container *di.Container,
+	cfg *config.UncorsConfig,
+	cfgPath string,
+) error {
+	app := uncor.NewUncorsApp(
+		container,
+		cfgPath,
+		cfg,
+		func() *config.UncorsConfig {
+			reloaded, _, _ := config.LoadConfiguration(container.Fs(), container.Version(), container.Args())
+
+			return reloaded
+		},
+	)
+
+	_, err := tea.NewProgram(app, tea.WithContext(ctx)).
+		Run()
+
+	return err
+}

internal/cli/run_non_ineractive.go

@@ -0,0 +1,124 @@
+package cli
+
+import (
+	"context"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/evg4b/uncors/internal/config"
+	"github.com/evg4b/uncors/internal/di"
+	"github.com/evg4b/uncors/internal/server"
+	"github.com/evg4b/uncors/internal/tui"
+)
+
+const shutdownTimeout = 15 * time.Second
+
+func runNonIneractive(
+	ctx context.Context,
+	container *di.Container,
+	cfg *config.UncorsConfig,
+	cfgPath string,
+) error {
+	output := container.CliOutput()
+	tui.PrintLogo(output, container.Version())
+	output.Print("")
+	output.WarnBox(tui.DisclaimerMessage)
+	output.Print("")
+	output.InfoBox(cfg.Mappings.String())
+	output.Print("")
+
+	targets, err := container.Targets(cfg)
+	if err != nil {
+		return err
+	}
+
+	srv := container.Server()
+
+	err = srv.Start(ctx, targets)
+	if err != nil {
+		return err
+	}
+
+	go startVersionChecker(ctx, container, cfg.Proxy)
+
+	go func() {
+		watcher := config.NewWatcher(cfgPath)
+
+		err := watcher.Watch(ctx, func() { reloadServer(ctx, container, srv) })
+		if err != nil {
+			output.Error(err)
+		}
+	}()
+
+	go func() { //nolint:gosec // G118: shutdown needs a fresh context because parent ctx is being cancelled
+		stop := make(chan os.Signal, 1)
+		signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
+
+		defer signal.Stop(stop)
+
+		select {
+		case sig := <-stop:
+			if sig == syscall.SIGINT {
+				_, _ = os.Stdout.WriteString("\n")
+			}
+
+			log.Println("shutdown signal received")
+		case <-ctx.Done():
+		}
+
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
+		defer cancel()
+
+		_ = srv.Shutdown(shutdownCtx)
+	}()
+
+	srv.Wait()
+	output.Info("Server was stopped")
+
+	return nil
+}
+
+func reloadServer(ctx context.Context, container *di.Container, srv *server.Server) {
+	output := container.CliOutput()
+
+	newUncorsConfig, _, err := config.LoadConfiguration(container.Fs(), container.Version(), container.Args())
+	if err != nil {
+		output.Error(err)
+
+		return
+	}
+
+	output.Info("Restarting server....")
+
+	targets, err := container.Targets(newUncorsConfig)
+	if err != nil {
+		output.Error(err)
+
+		return
+	}
+
+	err = srv.Restart(ctx, targets)
+	if err != nil {
+		output.Error(err)
+
+		return
+	}
+
+	output.InfoBox(
+		"Server restarted",
+		newUncorsConfig.Mappings.String(),
+	)
+}
+
+// startVersionChecker waits for a short delay then checks for a newer release.
+func startVersionChecker(ctx context.Context, container *di.Container, proxy string) {
+	const checkDelay = 50 * time.Millisecond
+
+	time.Sleep(checkDelay)
+
+	container.VersionChecker(proxy).
+		CheckNewVersion(ctx)
+}

internal/cli/run_uncors.go

@@ -0,0 +1,42 @@
+package cli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/evg4b/uncors/internal/config"
+	"github.com/evg4b/uncors/internal/di"
+	"github.com/spf13/pflag"
+)
+
+func RunUncors(ctx context.Context, container *di.Container) error {
+	uncorsConfig, path, err := config.LoadConfiguration(container.Fs(), container.Version(), container.Args())
+	if err != nil {
+		if errors.Is(err, config.ErrVersionRequested) {
+			fmt.Fprintln(os.Stdout, container.Version())
+
+			return nil
+		}
+
+		if errors.Is(err, pflag.ErrHelp) {
+			return nil
+		}
+
+		return err
+	}
+
+	var runError error
+	if uncorsConfig.Interactive {
+		runError = runIneractive(ctx, container, uncorsConfig, path)
+	} else {
+		runError = runNonIneractive(ctx, container, uncorsConfig, path)
+	}
+
+	if runError != nil && !errors.Is(runError, pflag.ErrHelp) {
+		return runError
+	}
+
+	return nil
+}