Have esi accept an optional http muxer

esi_sso.go

@@ -44,6 +44,7 @@ type SSO struct {
 	db           DB
 	mu           sync.Mutex
 	server       *http.Server
+	mux          *http.ServeMux
 	state        string
 	callbackChan chan struct {
 		code  string
@@ -78,6 +79,12 @@ func NewSSO(clientID, redirectURI string, scopes []string) (*SSO, error) {
 	return s, nil
 }
 
+// SetMuxer allows the SSO to use an existing HTTP muxer instead of creating its own server
+func (s *SSO) SetMuxer(mux *http.ServeMux) {
+	s.mux = mux
+	logger.Debug("SSO configured to use existing HTTP muxer")
+}
+
 func (s *SSO) initDB() error {
 	logger.Debug("Initializing SSO database schema")
 	err := s.db.AutoMigrate(&Token{})
@@ -173,8 +180,12 @@ func (s *SSO) startAuthFlow(ctx context.Context, characterName string) error {
 	logger.Info("Please visit this URL to authenticate: \n%s", authURL)
 	logger.Info("Waiting for authentication...")
 
-	// Start callback server
+	// Setup callback handling
-	logger.Debug("Starting callback server")
+	if s.mux != nil {
+		logger.Debug("Using existing HTTP muxer for callback handling")
+		s.setupCallbackHandler()
+	} else {
+		logger.Debug("Starting dedicated callback server")
 		server, err := s.startCallbackServer()
 		if err != nil {
 			logger.Error("Failed to start callback server: %v", err)
@@ -182,6 +193,7 @@ func (s *SSO) startAuthFlow(ctx context.Context, characterName string) error {
 		}
 		s.server = server
 		defer server.Shutdown(ctx)
+	}
 
 	// Wait for callback
 	logger.Debug("Waiting for authentication callback")
@@ -231,29 +243,18 @@ func (s *SSO) buildAuthURL(challenge, state string) string {
 	return issuerAuthorizeURL + "?" + q.Encode()
 }
 
-func (s *SSO) startCallbackServer() (*http.Server, error) {
+func (s *SSO) setupCallbackHandler() {
-	logger.Debug("Starting callback server for redirect URI: %s", s.redirectURI)
 	u, err := url.Parse(s.redirectURI)
 	if err != nil {
-		logger.Error("Failed to parse redirect URI: %v", err)
+		logger.Error("Failed to parse redirect URI for callback handler: %v", err)
-		return nil, err
+		return
-	}
-	if u.Scheme != "http" && u.Scheme != "https" {
-		logger.Error("Invalid redirect URI scheme: %s", u.Scheme)
-		return nil, errors.New("redirect URI must be http(s)")
-	}
-	hostPort := u.Host
-	if !strings.Contains(hostPort, ":") {
-		if u.Scheme == "https" {
-			hostPort += ":443"
-		} else {
-			hostPort += ":80"
-		}
 	}
 
-	logger.Debug("Callback server will listen on %s", hostPort)
+	logger.Debug("Setting up callback handler on path: %s", u.Path)
-	mux := http.NewServeMux()
+	s.mux.HandleFunc(u.Path, s.handleCallback)
-	mux.HandleFunc(u.Path, func(w http.ResponseWriter, r *http.Request) {
+}
+
+func (s *SSO) handleCallback(w http.ResponseWriter, r *http.Request) {
 	logger.Debug("Received callback request: %s %s", r.Method, r.URL.String())
 	if r.Method != http.MethodGet {
 		logger.Warning("Invalid callback method: %s", r.Method)
@@ -287,11 +288,31 @@ func (s *SSO) startCallbackServer() (*http.Server, error) {
 		state string
 		err   error
 	}{code, st, nil}
-		go func() {
+}
-			time.Sleep(200 * time.Millisecond)
+
-			_ = s.server.Shutdown(context.Background())
+func (s *SSO) startCallbackServer() (*http.Server, error) {
-		}()
+	logger.Debug("Starting dedicated callback server for redirect URI: %s", s.redirectURI)
-	})
+	u, err := url.Parse(s.redirectURI)
+	if err != nil {
+		logger.Error("Failed to parse redirect URI: %v", err)
+		return nil, err
+	}
+	if u.Scheme != "http" && u.Scheme != "https" {
+		logger.Error("Invalid redirect URI scheme: %s", u.Scheme)
+		return nil, errors.New("redirect URI must be http(s)")
+	}
+	hostPort := u.Host
+	if !strings.Contains(hostPort, ":") {
+		if u.Scheme == "https" {
+			hostPort += ":443"
+		} else {
+			hostPort += ":80"
+		}
+	}
+
+	logger.Debug("Callback server will listen on %s", hostPort)
+	mux := http.NewServeMux()
+	mux.HandleFunc(u.Path, s.handleCallback)
 
 	ln, err := net.Listen("tcp", hostPort)
 	if err != nil {

main.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"flag"
 	"fmt"
-
+	"net/http"
 	"os"
 	"strings"
 
@@ -45,7 +45,32 @@ func main() {
 		return
 	}
 
-	// Get token for character
+	// Setup HTTP server
+	mux := http.NewServeMux()
+
+	// Configure SSO to use existing muxer
+	sso.SetMuxer(mux)
+
+	// Add your own routes
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("EVE PI Server Running"))
+	})
+
+	// Start server
+	server := &http.Server{
+		Addr:    ":3000",
+		Handler: mux,
+	}
+
+	logger.Info("Starting web server on :3000")
+	go func() {
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Error("Server failed: %v", err)
+		}
+	}()
+
+	// Get token for character (this will add callback route temporarily)
 	token, err := sso.GetToken(context.Background(), "PhatPhuckDave")
 	if err != nil {
 		logger.Error("Failed to get token %v", err)