home-services/discord-bot/cmd/bot/main.go

package main

import (
	"context"
	"log/slog"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/bwmarrin/discordgo"
	"github.com/joho/godotenv"

	discordadapter "gitea.nik4nao.com/nik/home-services/discord-bot/internal/adapters/primary/discord"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/adapters/secondary/aigateway"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/adapters/secondary/gateway"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/adapters/secondary/ttsgateway"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/app"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/config"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/logger"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/modelstore"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/modelvalidator"
	"gitea.nik4nao.com/nik/home-services/discord-bot/internal/telemetry"
)

var version = "dev"

func main() {
	_ = godotenv.Load()

	// Config is loaded before logger setup so fatal startup errors still stop early.
	cfg, err := config.Load()
	if err != nil {
		os.Stderr.WriteString("config error: " + err.Error() + "\n")
		os.Exit(1)
	}

	log := logger.New(cfg.LogFormat, cfg.LogLevel)
	// Set the process-wide default so contexts created at library boundaries
	// still inherit the configured JSON/text handler.
	slog.SetDefault(log)
	log.Info("starting discord-bot",
		"version", version,
		"ha_gateway_addr", cfg.HAGatewayAddr,
		"ai_gateway_addr", cfg.AIGatewayAddr,
		"tts_gateway_addr", cfg.TTSGatewayAddr,
		"discord_token", redactToken(cfg.DiscordToken),
		"tls_dir", cfg.TLSDir,
		"log_level", cfg.LogLevel,
		"log_format", cfg.LogFormat,
	)

	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
	defer stop()
	ctx = logger.WithLogger(ctx, log)

	// Telemetry is optional; an empty OTEL endpoint installs no-op providers.
	shutdown, err := telemetry.Setup(ctx, "discord-bot", version, cfg)
	if err != nil {
		log.Error("telemetry setup failed", "err", err)
		os.Exit(1)
	}
	if cfg.OTELEndpoint != "" {
		log.Info("telemetry enabled", "endpoint", cfg.OTELEndpoint)
	} else {
		log.Debug("telemetry disabled")
	}

	haClient, err := gateway.New(ctx, cfg.HAGatewayAddr, cfg.TLSDir, log)
	if err != nil {
		log.Error("ha-gateway client setup failed", "err", err)
		os.Exit(1)
	}
	defer func() {
		if err := haClient.Close(); err != nil {
			log.Error("ha-gateway client close failed", "err", err)
		}
	}()

	aiClient, err := aigateway.New(ctx, cfg.AIGatewayAddr, cfg.TLSDir, log)
	if err != nil {
		log.Error("ai-gateway client setup failed", "err", err)
		os.Exit(1)
	}
	defer func() {
		if err := aiClient.Close(); err != nil {
			log.Error("ai-gateway client close failed", "err", err)
		}
	}()

	// TODO: pass cfg.TLSDir here once tts-gateway's own mTLS is re-enabled (currently
	// deliberately disabled there for plaintext testing - see tts-gateway.yaml's commented-out
	// TLS_DIR). Until then, dialing it with mTLS fails with "tls: first record does not look
	// like a TLS handshake" since the server isn't speaking TLS at all yet.
	ttsClient, err := ttsgateway.New(ctx, cfg.TTSGatewayAddr, "", log)
	if err != nil {
		log.Error("tts-gateway client setup failed", "err", err)
		os.Exit(1)
	}
	defer func() {
		if err := ttsClient.Close(); err != nil {
			log.Error("tts-gateway client close failed", "err", err)
		}
	}()

	modelStore := modelstore.New()
	validator := modelvalidator.New(aiClient, 30*time.Second)
	commandApp := app.NewCommandApp(haClient, aiClient, modelStore, validator, ttsClient)
	tracker := discordadapter.NewTracker(context.Background())

	// Discord-specific wiring stays at the edge so the app layer remains transport-agnostic.
	session, err := discordgo.New("Bot " + cfg.DiscordToken)
	if err != nil {
		log.Error("create discord session failed", "err", err)
		os.Exit(1)
	}
	// GuildVoiceStates is needed to resolve which voice channel the invoking
	// user is currently in for /speak (see internal/adapters/primary/discord/voice.go).
	session.Identify.Intents = discordgo.IntentsGuilds | discordgo.IntentsGuildVoiceStates

	handler := discordadapter.NewHandler(commandApp, tracker)
	handler.Register(session)

	if err := session.Open(); err != nil {
		log.Error("open discord session failed", "err", err)
		os.Exit(1)
	}
	log.Info("discord session ready", "bot_user", session.State.User.Username)

	if err := discordadapter.RegisterCommands(session, cfg.GuildID); err != nil {
		log.Error("register discord commands failed", "err", err)
		os.Exit(1)
	}

	scope := "global"
	if cfg.GuildID != "" {
		scope = cfg.GuildID
	}
	log.Info("discord bot started",
		"command_scope", scope,
		"ha_gateway_addr", cfg.HAGatewayAddr,
		"ai_gateway_addr", cfg.AIGatewayAddr,
		"tts_gateway_addr", cfg.TTSGatewayAddr,
		"version", version,
	)

	<-ctx.Done()
	log.Info("shutdown signal received, waiting for in-flight ai work")

	if clean := tracker.Shutdown(25 * time.Second); !clean {
		log.Warn("shutdown grace exceeded; some ai requests cancelled")
	}

	if err := session.Close(); err != nil {
		log.Error("close discord session failed", "err", err)
	}
	log.Info("shutdown complete")

	shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := shutdown(shutdownCtx); err != nil {
		log.Error("telemetry shutdown error", "err", err)
	}
}

// redactToken logs only a short prefix so startup logs remain useful without
// leaking the full Discord bot token.
func redactToken(token string) string {
	if token == "" {
		return "[not set]"
	}
	if len(token) <= 8 {
		return "[set]"
	}
	return token[:8] + "..."
}