main.go

package main

import (
	"context"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"log/slog"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"time"

	go2tvadapters "go2tv.app/mcp-beam/internal/adapters/go2tv"
	"go2tv.app/mcp-beam/internal/beam"
	"go2tv.app/mcp-beam/internal/buildinfo"
	"go2tv.app/mcp-beam/internal/diagnostics"
	"go2tv.app/mcp-beam/internal/discovery"
	"go2tv.app/mcp-beam/internal/lifecycle"
	"go2tv.app/mcp-beam/internal/mcpserver"
)

type selfTestOutput struct {
	Server struct {
		Name    string `json:"name"`
		Version string `json:"version"`
	} `json:"server"`
	Go2TVAdapters struct {
		DiscoveryWired bool `json:"discovery_wired"`
		CastWired      bool `json:"cast_wired"`
		DLNAWired      bool `json:"dlna_wired"`
	} `json:"go2tv_adapters"`
	Dependencies diagnostics.DependencyReport `json:"dependencies"`
}

func main() {
	selfTest := flag.Bool("self-test", false, "run dependency and wiring diagnostics then exit")
	showVersion := flag.Bool("version", false, "print version and exit")
	flag.Parse()

	if *showVersion {
		fmt.Println(buildinfo.Version)
		return
	}

	bundle := go2tvadapters.NewBundle()
	diag := diagnostics.DetectDependencies()

	if *selfTest {
		out := selfTestOutput{
			Dependencies: diag,
		}
		out.Server.Name = "mcp-beam"
		out.Server.Version = buildinfo.Version
		out.Go2TVAdapters.DiscoveryWired = bundle.Discovery != nil
		out.Go2TVAdapters.CastWired = bundle.CastFactory != nil
		out.Go2TVAdapters.DLNAWired = bundle.DLNAFactory != nil

		encoder := json.NewEncoder(os.Stdout)
		encoder.SetIndent("", "  ")
		if err := encoder.Encode(out); err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)
		}
		return
	}

	handleSIGINT := boolEnv("MCP_BEAM_HANDLE_SIGINT", false)
	if !handleSIGINT {
		signal.Ignore(os.Interrupt)
		defer signal.Reset(os.Interrupt)
	}
	termSignals := lifecycle.TerminationSignals(handleSIGINT)
	var (
		runCtx      context.Context
		stopSignals context.CancelFunc
	)
	if len(termSignals) == 0 {
		runCtx, stopSignals = context.WithCancel(context.Background())
	} else {
		runCtx, stopSignals = signal.NotifyContext(context.Background(), termSignals...)
	}
	defer stopSignals()

	logLevel := parseLogLevel(os.Getenv("MCP_BEAM_LOG_LEVEL"))
	logger := slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{
		Level: logLevel,
	}))
	logger.Info(
		"mcp_server_start",
		slog.String("server", "mcp-beam"),
		slog.String("version", buildinfo.Version),
		slog.String("log_level", logLevel.String()),
	)
	discoverySvc := discovery.NewService(bundle.Discovery, runCtx)
	beamManager := beam.NewManager(discoverySvc, bundle.CastFactory, bundle.DLNAFactory)
	srv := mcpserver.New(os.Stdin, os.Stdout, mcpserver.Config{
		ServerName:          "mcp-beam",
		ServerVersion:       buildinfo.Version,
		Logger:              logger,
		LocalHardwareLister: discoverySvc,
		BeamController:      beamManager,
	})

	runErrCh := make(chan error, 1)
	go func() {
		runErrCh <- srv.Run(runCtx)
	}()

	var runErr error
	select {
	case runErr = <-runErrCh:
	case <-runCtx.Done():
		runErr = runCtx.Err()
	}
	if runErr != nil {
		logger.Warn("mcp_server_stopping", slog.String("reason", runErr.Error()))
	} else {
		logger.Info("mcp_server_stopping", slog.String("reason", "clean_eof"))
	}

	shutdownCtx, cancelShutdown := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancelShutdown()
	if err := beamManager.Close(shutdownCtx); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	if runErr != nil && !errors.Is(runErr, context.Canceled) {
		fmt.Fprintln(os.Stderr, runErr)
		os.Exit(1)
	}
}

func parseLogLevel(raw string) slog.Level {
	switch strings.ToLower(strings.TrimSpace(raw)) {
	case "", "info":
		return slog.LevelInfo
	case "debug":
		return slog.LevelDebug
	case "warn", "warning":
		return slog.LevelWarn
	case "error":
		return slog.LevelError
	default:
		fmt.Fprintf(os.Stderr, "invalid MCP_BEAM_LOG_LEVEL=%q; defaulting to info\n", raw)
		return slog.LevelInfo
	}
}

func boolEnv(name string, defaultValue bool) bool {
	raw := strings.TrimSpace(os.Getenv(name))
	if raw == "" {
		return defaultValue
	}
	parsed, err := strconv.ParseBool(raw)
	if err != nil {
		return defaultValue
	}
	return parsed
}