Use sockets for server creation progress

local/service/server.go

@@ -31,6 +31,7 @@ type ServerService struct {
 	steamService     *SteamService
 	windowsService   *WindowsService
 	firewallService  *FirewallService
+	webSocketService *WebSocketService
 	instances        sync.Map // Track instances per server
 	lastInsertTimes  sync.Map // Track last insert time per server
 	debouncers       sync.Map // Track debounce timers per server
@@ -68,6 +69,7 @@ func NewServerService(
 	steamService *SteamService,
 	windowsService *WindowsService,
 	firewallService *FirewallService,
+	webSocketService *WebSocketService,
 ) *ServerService {
 	service := &ServerService{
 		repository:       repository,
@@ -77,6 +79,7 @@ func NewServerService(
 		steamService:     steamService,
 		windowsService:   windowsService,
 		firewallService:  firewallService,
+		webSocketService: webSocketService,
 	}
 
 	// Initialize server instances
@@ -203,6 +206,7 @@ func (s *ServerService) updateSessionDuration(server *model.Server, sessionType
 func (s *ServerService) GenerateServerPath(server *model.Server) {
 	// Get the base steamcmd path from environment variable
 	steamCMDPath := env.GetSteamCMDDirPath()
+	server.FromSteamCMD = true
 	server.Path = server.GenerateServerPath(steamCMDPath)
 }
 
@@ -330,50 +334,139 @@ func (as *ServerService) GetById(ctx *fiber.Ctx, serverID uuid.UUID) (*model.Ser
 	return server, nil
 }
 
-func (s *ServerService) CreateServer(ctx *fiber.Ctx, server *model.Server) error {
-	// Validate basic server configuration
+// CreateServerAsync starts server creation asynchronously and returns immediately
+func (s *ServerService) CreateServerAsync(ctx *fiber.Ctx, server *model.Server) error {
+	// Perform basic validation first
 	if err := server.Validate(); err != nil {
 		return err
 	}
 
-	// Install server using SteamCMD
-	if err := s.steamService.InstallServer(ctx.UserContext(), server.GetServerPath(), &server.ID); err != nil {
+	// Generate server path
+	s.GenerateServerPath(server)
+
+	// Create a background context that won't be cancelled when the HTTP request ends
+	bgCtx := context.Background()
+
+	// Start the actual creation process in a goroutine
+	go func() {
+		// Create server in background without using fiber.Ctx
+		if err := s.createServerBackground(bgCtx, server); err != nil {
+			logging.Error("Async server creation failed for server %s: %v", server.ID, err)
+			s.webSocketService.BroadcastError(server.ID, "Server creation failed", err.Error())
+			s.webSocketService.BroadcastComplete(server.ID, false, fmt.Sprintf("Server creation failed: %v", err))
+		}
+	}()
+
+	return nil
+}
+
+func (s *ServerService) CreateServer(ctx *fiber.Ctx, server *model.Server) error {
+	// Broadcast step: validation
+	s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusInProgress,
+		model.GetStepDescription(model.StepValidation), "")
+
+	// Validate basic server configuration
+	if err := server.Validate(); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusFailed,
+			"", fmt.Sprintf("Validation failed: %v", err))
+		return err
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusCompleted,
+		"Server configuration validated successfully", "")
+
+	// Broadcast step: directory creation
+	s.webSocketService.BroadcastStep(server.ID, model.StepDirectoryCreation, model.StatusInProgress,
+		model.GetStepDescription(model.StepDirectoryCreation), "")
+
+	// Directory creation is handled within InstallServer, so we mark it as completed
+	s.webSocketService.BroadcastStep(server.ID, model.StepDirectoryCreation, model.StatusCompleted,
+		"Server directories prepared", "")
+
+	// Broadcast step: Steam download
+	s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusInProgress,
+		model.GetStepDescription(model.StepSteamDownload), "")
+
+	// Install server using SteamCMD with streaming support
+	if err := s.steamService.InstallServerWithWebSocket(ctx.UserContext(), server.Path, &server.ID, s.webSocketService); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusFailed,
+			"", fmt.Sprintf("Steam installation failed: %v", err))
 		return fmt.Errorf("failed to install server: %v", err)
 	}
 
-	// Create Windows service with correct paths
-	execPath := filepath.Join(server.GetServerPath(), "accServer.exe")
-	serverWorkingDir := filepath.Join(server.GetServerPath(), "server")
-	if err := s.windowsService.CreateService(ctx.UserContext(), server.ServiceName, execPath, serverWorkingDir, nil); err != nil {
-		// Cleanup on failure
-		s.steamService.UninstallServer(server.Path)
-		return fmt.Errorf("failed to create Windows service: %v", err)
-	}
+	s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusCompleted,
+		"Server files downloaded successfully", "")
 
-	s.configureFirewall(server)
+	// Broadcast step: config generation
+	s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusInProgress,
+		model.GetStepDescription(model.StepConfigGeneration), "")
+
+	// Find available ports for server
 	ports, err := network.FindAvailablePortRange(DefaultStartPort, RequiredPortCount)
 	if err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusFailed,
+			"", fmt.Sprintf("Failed to find available ports: %v", err))
 		return fmt.Errorf("failed to find available ports: %v", err)
 	}
 
 	// Use the first port for both TCP and UDP
 	serverPort := ports[0]
+
+	// Update server configuration with the allocated port
+	if err := s.updateServerPort(server, serverPort); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusFailed,
+			"", fmt.Sprintf("Failed to update server configuration: %v", err))
+		return fmt.Errorf("failed to update server configuration: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusCompleted,
+		fmt.Sprintf("Server configuration generated (Port: %d)", serverPort), "")
+
+	// Broadcast step: service creation
+	s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusInProgress,
+		model.GetStepDescription(model.StepServiceCreation), "")
+
+	// Create Windows service with correct paths
+	execPath := filepath.Join(server.GetServerPath(), "accServer.exe")
+	serverWorkingDir := filepath.Join(server.GetServerPath(), "server")
+	if err := s.windowsService.CreateService(ctx.UserContext(), server.ServiceName, execPath, serverWorkingDir, nil); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusFailed,
+			"", fmt.Sprintf("Failed to create Windows service: %v", err))
+		// Cleanup on failure
+		s.steamService.UninstallServer(server.Path)
+		return fmt.Errorf("failed to create Windows service: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusCompleted,
+		fmt.Sprintf("Windows service '%s' created successfully", server.ServiceName), "")
+
+	// Broadcast step: firewall rules
+	s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusInProgress,
+		model.GetStepDescription(model.StepFirewallRules), "")
+
+	s.configureFirewall(server)
 	tcpPorts := []int{serverPort}
 	udpPorts := []int{serverPort}
 	if err := s.firewallService.CreateServerRules(server.ServiceName, tcpPorts, udpPorts); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusFailed,
+			"", fmt.Sprintf("Failed to create firewall rules: %v", err))
 		// Cleanup on failure
 		s.windowsService.DeleteService(ctx.UserContext(), server.ServiceName)
 		s.steamService.UninstallServer(server.Path)
 		return fmt.Errorf("failed to create firewall rules: %v", err)
 	}
 
-	// Update server configuration with the allocated port
-	if err := s.updateServerPort(server, serverPort); err != nil {
-		return fmt.Errorf("failed to update server configuration: %v", err)
-	}
+	s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusCompleted,
+		fmt.Sprintf("Firewall rules created for port %d", serverPort), "")
+
+	// Broadcast step: database save
+	s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusInProgress,
+		model.GetStepDescription(model.StepDatabaseSave), "")
 
 	// Insert server into database
 	if err := s.repository.Insert(ctx.UserContext(), server); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusFailed,
+			"", fmt.Sprintf("Failed to save server to database: %v", err))
 		// Cleanup on failure
 		s.firewallService.DeleteServerRules(server.ServiceName, tcpPorts, udpPorts)
 		s.windowsService.DeleteService(ctx.UserContext(), server.ServiceName)
@@ -381,9 +474,150 @@ func (s *ServerService) CreateServer(ctx *fiber.Ctx, server *model.Server) error
 		return fmt.Errorf("failed to insert server into database: %v", err)
 	}
 
+	s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusCompleted,
+		"Server saved to database successfully", "")
+
 	// Initialize server runtime
 	s.StartAccServerRuntime(server)
 
+	// Broadcast completion
+	s.webSocketService.BroadcastStep(server.ID, model.StepCompleted, model.StatusCompleted,
+		model.GetStepDescription(model.StepCompleted), "")
+
+	s.webSocketService.BroadcastComplete(server.ID, true,
+		fmt.Sprintf("Server '%s' created successfully on port %d", server.Name, serverPort))
+
+	return nil
+}
+
+// createServerBackground performs server creation in background without fiber.Ctx
+func (s *ServerService) createServerBackground(ctx context.Context, server *model.Server) error {
+	// Broadcast step: validation
+	s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusInProgress,
+		model.GetStepDescription(model.StepValidation), "")
+
+	// Validate basic server configuration (already done in async method, but double-check)
+	if err := server.Validate(); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusFailed,
+			"", fmt.Sprintf("Validation failed: %v", err))
+		return err
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepValidation, model.StatusCompleted,
+		"Server configuration validated successfully", "")
+
+	// Broadcast step: directory creation
+	s.webSocketService.BroadcastStep(server.ID, model.StepDirectoryCreation, model.StatusInProgress,
+		model.GetStepDescription(model.StepDirectoryCreation), "")
+
+	// Directory creation is handled within InstallServer, so we mark it as completed
+	s.webSocketService.BroadcastStep(server.ID, model.StepDirectoryCreation, model.StatusCompleted,
+		"Server directories prepared", "")
+
+	// Broadcast step: Steam download
+	s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusInProgress,
+		model.GetStepDescription(model.StepSteamDownload), "")
+
+	// Install server using SteamCMD with streaming support
+	if err := s.steamService.InstallServerWithWebSocket(ctx, server.GetServerPath(), &server.ID, s.webSocketService); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusFailed,
+			"", fmt.Sprintf("Steam installation failed: %v", err))
+		return fmt.Errorf("failed to install server: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepSteamDownload, model.StatusCompleted,
+		"Server files downloaded successfully", "")
+
+	// Broadcast step: config generation
+	s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusInProgress,
+		model.GetStepDescription(model.StepConfigGeneration), "")
+
+	// Find available ports for server
+	ports, err := network.FindAvailablePortRange(DefaultStartPort, RequiredPortCount)
+	if err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusFailed,
+			"", fmt.Sprintf("Failed to find available ports: %v", err))
+		return fmt.Errorf("failed to find available ports: %v", err)
+	}
+
+	// Use the first port for both TCP and UDP
+	serverPort := ports[0]
+
+	// Update server configuration with the allocated port
+	if err := s.updateServerPort(server, serverPort); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusFailed,
+			"", fmt.Sprintf("Failed to update server configuration: %v", err))
+		return fmt.Errorf("failed to update server configuration: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepConfigGeneration, model.StatusCompleted,
+		fmt.Sprintf("Server configuration generated (Port: %d)", serverPort), "")
+
+	// Broadcast step: service creation
+	s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusInProgress,
+		model.GetStepDescription(model.StepServiceCreation), "")
+
+	// Create Windows service with correct paths
+	execPath := filepath.Join(server.GetServerPath(), "accServer.exe")
+	serverWorkingDir := filepath.Join(server.GetServerPath(), "server")
+	if err := s.windowsService.CreateService(ctx, server.ServiceName, execPath, serverWorkingDir, nil); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusFailed,
+			"", fmt.Sprintf("Failed to create Windows service: %v", err))
+		// Cleanup on failure
+		s.steamService.UninstallServer(server.Path)
+		return fmt.Errorf("failed to create Windows service: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepServiceCreation, model.StatusCompleted,
+		fmt.Sprintf("Windows service '%s' created successfully", server.ServiceName), "")
+
+	// Broadcast step: firewall rules
+	s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusInProgress,
+		model.GetStepDescription(model.StepFirewallRules), "")
+
+	s.configureFirewall(server)
+	tcpPorts := []int{serverPort}
+	udpPorts := []int{serverPort}
+	if err := s.firewallService.CreateServerRules(server.ServiceName, tcpPorts, udpPorts); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusFailed,
+			"", fmt.Sprintf("Failed to create firewall rules: %v", err))
+		// Cleanup on failure
+		s.windowsService.DeleteService(ctx, server.ServiceName)
+		s.steamService.UninstallServer(server.Path)
+		return fmt.Errorf("failed to create firewall rules: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepFirewallRules, model.StatusCompleted,
+		fmt.Sprintf("Firewall rules created for port %d", serverPort), "")
+
+	// Broadcast step: database save
+	s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusInProgress,
+		model.GetStepDescription(model.StepDatabaseSave), "")
+
+	// Insert server into database
+	if err := s.repository.Insert(ctx, server); err != nil {
+		s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusFailed,
+			"", fmt.Sprintf("Failed to save server to database: %v", err))
+		// Cleanup on failure
+		s.firewallService.DeleteServerRules(server.ServiceName, tcpPorts, udpPorts)
+		s.windowsService.DeleteService(ctx, server.ServiceName)
+		s.steamService.UninstallServer(server.Path)
+		return fmt.Errorf("failed to insert server into database: %v", err)
+	}
+
+	s.webSocketService.BroadcastStep(server.ID, model.StepDatabaseSave, model.StatusCompleted,
+		"Server saved to database successfully", "")
+
+	// Initialize server runtime
+	s.StartAccServerRuntime(server)
+
+	// Broadcast completion
+	s.webSocketService.BroadcastStep(server.ID, model.StepCompleted, model.StatusCompleted,
+		model.GetStepDescription(model.StepCompleted), "")
+
+	s.webSocketService.BroadcastComplete(server.ID, true,
+		fmt.Sprintf("Server '%s' created successfully on port %d", server.Name, serverPort))
+
 	return nil
 }
 

local/service/service.go

@@ -27,6 +27,7 @@ func InitializeServices(c *dig.Container) {
 	c.Provide(NewWindowsService)
 	c.Provide(NewFirewallService)
 	c.Provide(NewMembershipService)
+	c.Provide(NewWebSocketService)
 
 	logging.Debug("Initializing service dependencies")
 	err := c.Invoke(func(server *ServerService, api *ServiceControlService, config *ConfigService) {

local/service/steam_service.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/google/uuid"
@@ -131,11 +132,13 @@ func (s *SteamService) InstallServer(ctx context.Context, installPath string, se
 	}
 
 	if creds != nil && creds.Username != "" {
+		logging.Info("Using Steam credentials for user: %s", creds.Username)
 		steamCMDArgs = append(steamCMDArgs, creds.Username)
 		if creds.Password != "" {
 			steamCMDArgs = append(steamCMDArgs, creds.Password)
 		}
 	} else {
+		logging.Info("Using anonymous Steam login")
 		steamCMDArgs = append(steamCMDArgs, "anonymous")
 	}
 
@@ -145,37 +148,196 @@ func (s *SteamService) InstallServer(ctx context.Context, installPath string, se
 		"+quit",
 	)
 
-	// Build PowerShell arguments to execute SteamCMD directly
-	// This matches the format: powershell -nologo -noprofile c:\steamcmd\steamcmd.exe +args...
-	args := []string{"-nologo", "-noprofile"}
-	args = append(args, steamCMDPath)
-	args = append(args, steamCMDArgs...)
+	// Execute SteamCMD directly without PowerShell wrapper to get better output capture
+	args := steamCMDArgs
 
 	// Use interactive executor to handle potential 2FA prompts with timeout
 	logging.Info("Installing ACC server to %s...", absPath)
-	
+	logging.Info("SteamCMD command: %s %s", steamCMDPath, strings.Join(args, " "))
+
 	// Create a context with timeout to prevent hanging indefinitely
-	timeoutCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
+	timeoutCtx, cancel := context.WithTimeout(ctx, 15*time.Minute) // Increased timeout
 	defer cancel()
-	
+
+	// Update the executor to use SteamCMD directly
+	originalExePath := s.interactiveExecutor.ExePath
+	s.interactiveExecutor.ExePath = steamCMDPath
+	defer func() {
+		s.interactiveExecutor.ExePath = originalExePath
+	}()
+
 	if err := s.interactiveExecutor.ExecuteInteractive(timeoutCtx, serverID, args...); err != nil {
+		logging.Error("SteamCMD execution failed: %v", err)
 		if timeoutCtx.Err() == context.DeadlineExceeded {
-			return fmt.Errorf("SteamCMD operation timed out after 10 minutes")
+			return fmt.Errorf("SteamCMD operation timed out after 15 minutes - this usually means Steam Guard confirmation is required")
 		}
 		return fmt.Errorf("failed to run SteamCMD: %v", err)
 	}
 
+	logging.Info("SteamCMD execution completed successfully, proceeding with verification...")
+
 	// Add a delay to allow Steam to properly cleanup
 	logging.Info("Waiting for Steam operations to complete...")
 	time.Sleep(5 * time.Second)
 
 	// Verify installation
 	exePath := filepath.Join(absPath, "server", "accServer.exe")
+	logging.Info("Checking for ACC server executable at: %s", exePath)
+
 	if _, err := os.Stat(exePath); os.IsNotExist(err) {
-		return fmt.Errorf("server installation failed: accServer.exe not found in %s", absPath)
+		// Log directory contents to help debug
+		logging.Info("accServer.exe not found, checking directory contents...")
+		if entries, dirErr := os.ReadDir(absPath); dirErr == nil {
+			logging.Info("Contents of %s:", absPath)
+			for _, entry := range entries {
+				logging.Info("  - %s (dir: %v)", entry.Name(), entry.IsDir())
+			}
+		}
+
+		// Check if there's a server subdirectory
+		serverDir := filepath.Join(absPath, "server")
+		if entries, dirErr := os.ReadDir(serverDir); dirErr == nil {
+			logging.Info("Contents of %s:", serverDir)
+			for _, entry := range entries {
+				logging.Info("  - %s (dir: %v)", entry.Name(), entry.IsDir())
+			}
+		} else {
+			logging.Info("Server directory %s does not exist or cannot be read: %v", serverDir, dirErr)
+		}
+
+		return fmt.Errorf("server installation failed: accServer.exe not found in %s", exePath)
 	}
 
-	logging.Info("Server installation completed successfully")
+	logging.Info("Server installation completed successfully - accServer.exe found at %s", exePath)
+	return nil
+}
+
+// InstallServerWithWebSocket installs a server with WebSocket output streaming
+func (s *SteamService) InstallServerWithWebSocket(ctx context.Context, installPath string, serverID *uuid.UUID, wsService *WebSocketService) error {
+	if err := s.ensureSteamCMD(ctx); err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Error ensuring SteamCMD: %v", err), true)
+		return err
+	}
+
+	// Validate installation path for security
+	if err := s.pathValidator.ValidateInstallPath(installPath); err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Invalid installation path: %v", err), true)
+		return fmt.Errorf("invalid installation path: %v", err)
+	}
+
+	// Convert to absolute path and ensure proper Windows path format
+	absPath, err := filepath.Abs(installPath)
+	if err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Failed to get absolute path: %v", err), true)
+		return fmt.Errorf("failed to get absolute path: %v", err)
+	}
+	absPath = filepath.Clean(absPath)
+
+	// Ensure install path exists
+	if err := os.MkdirAll(absPath, 0755); err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Failed to create install directory: %v", err), true)
+		return fmt.Errorf("failed to create install directory: %v", err)
+	}
+
+	wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Installation directory prepared: %s", absPath), false)
+
+	// Get Steam credentials
+	creds, err := s.GetCredentials(ctx)
+	if err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Failed to get Steam credentials: %v", err), true)
+		return fmt.Errorf("failed to get Steam credentials: %v", err)
+	}
+
+	// Get SteamCMD path from environment variable
+	steamCMDPath := env.GetSteamCMDPath()
+
+	// Build SteamCMD command arguments
+	steamCMDArgs := []string{
+		"+force_install_dir", absPath,
+		"+login",
+	}
+
+	if creds != nil && creds.Username != "" {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Using Steam credentials for user: %s", creds.Username), false)
+		steamCMDArgs = append(steamCMDArgs, creds.Username)
+		if creds.Password != "" {
+			steamCMDArgs = append(steamCMDArgs, creds.Password)
+		}
+	} else {
+		wsService.BroadcastSteamOutput(*serverID, "Using anonymous Steam login", false)
+		steamCMDArgs = append(steamCMDArgs, "anonymous")
+	}
+
+	steamCMDArgs = append(steamCMDArgs,
+		"+app_update", ACCServerAppID,
+		"validate",
+		"+quit",
+	)
+
+	// Execute SteamCMD with WebSocket output streaming
+	args := steamCMDArgs
+
+	wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Starting SteamCMD: %s %s", steamCMDPath, strings.Join(args, " ")), false)
+
+	// Create a context with timeout to prevent hanging indefinitely
+	timeoutCtx, cancel := context.WithTimeout(ctx, 15*time.Minute)
+	defer cancel()
+
+	// Update the executor to use SteamCMD directly
+	originalExePath := s.interactiveExecutor.ExePath
+	s.interactiveExecutor.ExePath = steamCMDPath
+	defer func() {
+		s.interactiveExecutor.ExePath = originalExePath
+	}()
+
+	// Create a modified interactive executor that streams output to WebSocket
+	wsInteractiveExecutor := command.NewInteractiveCommandExecutorWithWebSocket(s.executor, s.tfaManager, wsService, *serverID)
+	wsInteractiveExecutor.ExePath = steamCMDPath
+
+	if err := wsInteractiveExecutor.ExecuteInteractive(timeoutCtx, serverID, args...); err != nil {
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("SteamCMD execution failed: %v", err), true)
+		if timeoutCtx.Err() == context.DeadlineExceeded {
+			return fmt.Errorf("SteamCMD operation timed out after 15 minutes - this usually means Steam Guard confirmation is required")
+		}
+		return fmt.Errorf("failed to run SteamCMD: %v", err)
+	}
+
+	wsService.BroadcastSteamOutput(*serverID, "SteamCMD execution completed successfully, proceeding with verification...", false)
+
+	// Add a delay to allow Steam to properly cleanup
+	wsService.BroadcastSteamOutput(*serverID, "Waiting for Steam operations to complete...", false)
+	time.Sleep(5 * time.Second)
+
+	// Verify installation
+	exePath := filepath.Join(absPath, "server", "accServer.exe")
+	wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Checking for ACC server executable at: %s", exePath), false)
+
+	if _, err := os.Stat(exePath); os.IsNotExist(err) {
+		wsService.BroadcastSteamOutput(*serverID, "accServer.exe not found, checking directory contents...", false)
+
+		if entries, dirErr := os.ReadDir(absPath); dirErr == nil {
+			wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Contents of %s:", absPath), false)
+			for _, entry := range entries {
+				wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("  - %s (dir: %v)", entry.Name(), entry.IsDir()), false)
+			}
+		}
+
+		// Check if there's a server subdirectory
+		serverDir := filepath.Join(absPath, "server")
+		if entries, dirErr := os.ReadDir(serverDir); dirErr == nil {
+			wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Contents of %s:", serverDir), false)
+			for _, entry := range entries {
+				wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("  - %s (dir: %v)", entry.Name(), entry.IsDir()), false)
+			}
+		} else {
+			wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Server directory %s does not exist or cannot be read: %v", serverDir, dirErr), true)
+		}
+
+		wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Server installation failed: accServer.exe not found in %s", exePath), true)
+		return fmt.Errorf("server installation failed: accServer.exe not found in %s", exePath)
+	}
+
+	wsService.BroadcastSteamOutput(*serverID, fmt.Sprintf("Server installation completed successfully - accServer.exe found at %s", exePath), false)
 	return nil
 }
 

local/service/websocket.go

@@ -0,0 +1,186 @@
+package service
+
+import (
+	"acc-server-manager/local/model"
+	"acc-server-manager/local/utl/logging"
+	"encoding/json"
+	"sync"
+	"time"
+
+	"github.com/gofiber/websocket/v2"
+	"github.com/google/uuid"
+)
+
+// WebSocketConnection represents a single WebSocket connection
+type WebSocketConnection struct {
+	conn     *websocket.Conn
+	serverID *uuid.UUID // If connected to a specific server creation process
+	userID   *uuid.UUID // User who owns this connection
+}
+
+// WebSocketService manages WebSocket connections and message broadcasting
+type WebSocketService struct {
+	connections sync.Map // map[string]*WebSocketConnection - key is connection ID
+	mu          sync.RWMutex
+}
+
+// NewWebSocketService creates a new WebSocket service
+func NewWebSocketService() *WebSocketService {
+	return &WebSocketService{}
+}
+
+// AddConnection adds a new WebSocket connection
+func (ws *WebSocketService) AddConnection(connID string, conn *websocket.Conn, userID *uuid.UUID) {
+	wsConn := &WebSocketConnection{
+		conn:   conn,
+		userID: userID,
+	}
+	ws.connections.Store(connID, wsConn)
+	logging.Info("WebSocket connection added: %s for user: %v", connID, userID)
+}
+
+// RemoveConnection removes a WebSocket connection
+func (ws *WebSocketService) RemoveConnection(connID string) {
+	if conn, exists := ws.connections.LoadAndDelete(connID); exists {
+		if wsConn, ok := conn.(*WebSocketConnection); ok {
+			wsConn.conn.Close()
+		}
+	}
+	logging.Info("WebSocket connection removed: %s", connID)
+}
+
+// SetServerID associates a connection with a specific server creation process
+func (ws *WebSocketService) SetServerID(connID string, serverID uuid.UUID) {
+	if conn, exists := ws.connections.Load(connID); exists {
+		if wsConn, ok := conn.(*WebSocketConnection); ok {
+			wsConn.serverID = &serverID
+		}
+	}
+}
+
+// BroadcastStep sends a step update to all connections associated with a server
+func (ws *WebSocketService) BroadcastStep(serverID uuid.UUID, step model.ServerCreationStep, status model.StepStatus, message string, errorMsg string) {
+	stepMsg := model.StepMessage{
+		Step:    step,
+		Status:  status,
+		Message: message,
+		Error:   errorMsg,
+	}
+
+	wsMsg := model.WebSocketMessage{
+		Type:      model.MessageTypeStep,
+		ServerID:  &serverID,
+		Timestamp: time.Now().Unix(),
+		Data:      stepMsg,
+	}
+
+	ws.broadcastToServer(serverID, wsMsg)
+}
+
+// BroadcastSteamOutput sends Steam command output to all connections associated with a server
+func (ws *WebSocketService) BroadcastSteamOutput(serverID uuid.UUID, output string, isError bool) {
+	steamMsg := model.SteamOutputMessage{
+		Output:  output,
+		IsError: isError,
+	}
+
+	wsMsg := model.WebSocketMessage{
+		Type:      model.MessageTypeSteamOutput,
+		ServerID:  &serverID,
+		Timestamp: time.Now().Unix(),
+		Data:      steamMsg,
+	}
+
+	ws.broadcastToServer(serverID, wsMsg)
+}
+
+// BroadcastError sends an error message to all connections associated with a server
+func (ws *WebSocketService) BroadcastError(serverID uuid.UUID, error string, details string) {
+	errorMsg := model.ErrorMessage{
+		Error:   error,
+		Details: details,
+	}
+
+	wsMsg := model.WebSocketMessage{
+		Type:      model.MessageTypeError,
+		ServerID:  &serverID,
+		Timestamp: time.Now().Unix(),
+		Data:      errorMsg,
+	}
+
+	ws.broadcastToServer(serverID, wsMsg)
+}
+
+// BroadcastComplete sends a completion message to all connections associated with a server
+func (ws *WebSocketService) BroadcastComplete(serverID uuid.UUID, success bool, message string) {
+	completeMsg := model.CompleteMessage{
+		ServerID: serverID,
+		Success:  success,
+		Message:  message,
+	}
+
+	wsMsg := model.WebSocketMessage{
+		Type:      model.MessageTypeComplete,
+		ServerID:  &serverID,
+		Timestamp: time.Now().Unix(),
+		Data:      completeMsg,
+	}
+
+	ws.broadcastToServer(serverID, wsMsg)
+}
+
+// broadcastToServer sends a message to all connections associated with a specific server
+func (ws *WebSocketService) broadcastToServer(serverID uuid.UUID, message model.WebSocketMessage) {
+	data, err := json.Marshal(message)
+	if err != nil {
+		logging.Error("Failed to marshal WebSocket message: %v", err)
+		return
+	}
+
+	ws.connections.Range(func(key, value interface{}) bool {
+		if wsConn, ok := value.(*WebSocketConnection); ok {
+			// Send to connections associated with this server
+			if wsConn.serverID != nil && *wsConn.serverID == serverID {
+				if err := wsConn.conn.WriteMessage(websocket.TextMessage, data); err != nil {
+					logging.Error("Failed to send WebSocket message to connection %s: %v", key, err)
+					// Remove the connection if it's broken
+					ws.RemoveConnection(key.(string))
+				}
+			}
+		}
+		return true
+	})
+}
+
+// BroadcastToUser sends a message to all connections owned by a specific user
+func (ws *WebSocketService) BroadcastToUser(userID uuid.UUID, message model.WebSocketMessage) {
+	data, err := json.Marshal(message)
+	if err != nil {
+		logging.Error("Failed to marshal WebSocket message: %v", err)
+		return
+	}
+
+	ws.connections.Range(func(key, value interface{}) bool {
+		if wsConn, ok := value.(*WebSocketConnection); ok {
+			// Send to connections owned by this user
+			if wsConn.userID != nil && *wsConn.userID == userID {
+				if err := wsConn.conn.WriteMessage(websocket.TextMessage, data); err != nil {
+					logging.Error("Failed to send WebSocket message to connection %s: %v", key, err)
+					// Remove the connection if it's broken
+					ws.RemoveConnection(key.(string))
+				}
+			}
+		}
+		return true
+	})
+}
+
+// GetActiveConnections returns the count of active connections
+func (ws *WebSocketService) GetActiveConnections() int {
+	count := 0
+	ws.connections.Range(func(key, value interface{}) bool {
+		count++
+		return true
+	})
+	return count
+}