Initial commit

backend/internal/services/config_manager.go

@@ -0,0 +1,89 @@
+package services
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type ConfigManager struct {
+	cfgDir string
+}
+
+func NewConfigManager(cfgDir string) *ConfigManager {
+	return &ConfigManager{cfgDir: cfgDir}
+}
+
+type ConfigInfo struct {
+	Name    string `json:"name"`
+	Size    int64  `json:"size"`
+}
+
+func (cm *ConfigManager) List() ([]ConfigInfo, error) {
+	entries, err := os.ReadDir(cm.cfgDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []ConfigInfo{}, nil
+		}
+		return nil, err
+	}
+
+	var configs []ConfigInfo
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(e.Name(), ".cfg") {
+			info, _ := e.Info()
+			configs = append(configs, ConfigInfo{
+				Name: strings.TrimSuffix(e.Name(), ".cfg"),
+				Size: info.Size(),
+			})
+		}
+	}
+	return configs, nil
+}
+
+func (cm *ConfigManager) Get(name string) (string, error) {
+	path := cm.path(name)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", fmt.Errorf("config not found")
+		}
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (cm *ConfigManager) Create(name, content string) error {
+	path := cm.path(name)
+	if _, err := os.Stat(path); err == nil {
+		return fmt.Errorf("config already exists")
+	}
+	return os.WriteFile(path, []byte(content), 0644)
+}
+
+func (cm *ConfigManager) Update(name, content string) error {
+	return os.WriteFile(cm.path(name), []byte(content), 0644)
+}
+
+func (cm *ConfigManager) Delete(name string) error {
+	return os.Remove(cm.path(name))
+}
+
+func (cm *ConfigManager) Duplicate(name, newName string) error {
+	content, err := cm.Get(name)
+	if err != nil {
+		return err
+	}
+	return cm.Create(newName, content)
+}
+
+func (cm *ConfigManager) path(name string) string {
+	return filepath.Join(cm.cfgDir, sanitizeConfigName(name)+".cfg")
+}
+
+func sanitizeConfigName(name string) string {
+	name = filepath.Base(name)
+	name = strings.TrimSuffix(name, ".cfg")
+	return name
+}

backend/internal/services/log_streamer.go

@@ -0,0 +1,81 @@
+package services
+
+import (
+	"bufio"
+	"io"
+	"log"
+	"sync"
+)
+
+type LogStreamer struct {
+	mu      sync.RWMutex
+	subs    map[string]map[string]chan string
+}
+
+func NewLogStreamer() *LogStreamer {
+	return &LogStreamer{
+		subs: make(map[string]map[string]chan string),
+	}
+}
+
+func (ls *LogStreamer) Subscribe(serverID, clientID string) chan string {
+	ls.mu.Lock()
+	defer ls.mu.Unlock()
+
+	if ls.subs[serverID] == nil {
+		ls.subs[serverID] = make(map[string]chan string)
+	}
+
+	ch := make(chan string, 256)
+	ls.subs[serverID][clientID] = ch
+	return ch
+}
+
+func (ls *LogStreamer) Unsubscribe(serverID, clientID string) {
+	ls.mu.Lock()
+	defer ls.mu.Unlock()
+
+	if ls.subs[serverID] != nil {
+		if ch, ok := ls.subs[serverID][clientID]; ok {
+			close(ch)
+			delete(ls.subs[serverID], clientID)
+		}
+		if len(ls.subs[serverID]) == 0 {
+			delete(ls.subs, serverID)
+		}
+	}
+}
+
+func (ls *LogStreamer) Stream(serverID string, reader io.Reader, closeMsg string) {
+	scanner := bufio.NewScanner(reader)
+	for scanner.Scan() {
+		line := scanner.Text()
+		ls.broadcast(serverID, line)
+	}
+	if err := scanner.Err(); err != nil {
+		log.Printf("log stream error for server %s: %v", serverID, err)
+	}
+	if closeMsg != "" {
+		ls.broadcast(serverID, closeMsg)
+	}
+}
+
+func (ls *LogStreamer) Broadcast(serverID, line string) {
+	ls.broadcast(serverID, line)
+}
+
+func (ls *LogStreamer) broadcast(serverID, line string) {
+	ls.mu.RLock()
+	defer ls.mu.RUnlock()
+
+	if ls.subs[serverID] == nil {
+		return
+	}
+
+	for _, ch := range ls.subs[serverID] {
+		select {
+		case ch <- line:
+		default:
+		}
+	}
+}

backend/internal/services/modlist_manager.go

@@ -0,0 +1,182 @@
+package services
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"arma3-web-server/internal/models"
+
+	"github.com/google/uuid"
+)
+
+type ModlistManager struct {
+	dir string
+	mu  sync.RWMutex
+}
+
+func NewModlistManager(dataDir string) *ModlistManager {
+	return &ModlistManager{
+		dir: filepath.Join(dataDir, "modlists"),
+	}
+}
+
+func (mm *ModlistManager) path(id string) string {
+	return filepath.Join(mm.dir, id+".json")
+}
+
+func (mm *ModlistManager) List() ([]models.ModlistListItem, error) {
+	mm.mu.RLock()
+	defer mm.mu.RUnlock()
+
+	entries, err := os.ReadDir(mm.dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []models.ModlistListItem{}, nil
+		}
+		return nil, err
+	}
+
+	var items []models.ModlistListItem
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".json") {
+			continue
+		}
+		data, err := os.ReadFile(filepath.Join(mm.dir, e.Name()))
+		if err != nil {
+			continue
+		}
+		var m models.Modlist
+		if err := json.Unmarshal(data, &m); err != nil {
+			continue
+		}
+		items = append(items, models.ModlistListItem{
+			ID:        m.ID,
+			Name:      m.Name,
+			ModCount:  len(m.Mods),
+			CreatedAt: m.CreatedAt,
+			UpdatedAt: m.UpdatedAt,
+		})
+	}
+	return items, nil
+}
+
+func (mm *ModlistManager) Get(id string) (*models.Modlist, error) {
+	mm.mu.RLock()
+	defer mm.mu.RUnlock()
+
+	data, err := os.ReadFile(mm.path(id))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("modlist not found")
+		}
+		return nil, err
+	}
+	var m models.Modlist
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+func (mm *ModlistManager) Create(name string) (*models.Modlist, error) {
+	mm.mu.Lock()
+	defer mm.mu.Unlock()
+
+	now := time.Now().UTC()
+	m := &models.Modlist{
+		ID:        uuid.New().String(),
+		Name:      name,
+		Mods:      []models.ModEntry{},
+		CreatedAt: now,
+		UpdatedAt: now,
+	}
+
+	data, err := json.MarshalIndent(m, "", "  ")
+	if err != nil {
+		return nil, err
+	}
+	if err := os.MkdirAll(mm.dir, 0755); err != nil {
+		return nil, err
+	}
+	if err := os.WriteFile(mm.path(m.ID), data, 0644); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (mm *ModlistManager) Update(id, name string, mods []models.ModEntry) (*models.Modlist, error) {
+	mm.mu.Lock()
+	defer mm.mu.Unlock()
+
+	m, err := mm.getLocked(id)
+	if err != nil {
+		return nil, err
+	}
+
+	m.Name = name
+	m.Mods = mods
+	m.UpdatedAt = time.Now().UTC()
+
+	data, err := json.MarshalIndent(m, "", "  ")
+	if err != nil {
+		return nil, err
+	}
+	if err := os.WriteFile(mm.path(id), data, 0644); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (mm *ModlistManager) Delete(id string) error {
+	mm.mu.Lock()
+	defer mm.mu.Unlock()
+	return os.Remove(mm.path(id))
+}
+
+func (mm *ModlistManager) Duplicate(id, newName string) (*models.Modlist, error) {
+	mm.mu.Lock()
+	defer mm.mu.Unlock()
+
+	orig, err := mm.getLocked(id)
+	if err != nil {
+		return nil, err
+	}
+
+	now := time.Now().UTC()
+	dup := &models.Modlist{
+		ID:        uuid.New().String(),
+		Name:      newName,
+		Mods:      orig.Mods,
+		CreatedAt: now,
+		UpdatedAt: now,
+	}
+
+	data, err := json.MarshalIndent(dup, "", "  ")
+	if err != nil {
+		return nil, err
+	}
+	if err := os.WriteFile(mm.path(dup.ID), data, 0644); err != nil {
+		return nil, err
+	}
+	return dup, nil
+}
+
+func (mm *ModlistManager) getLocked(id string) (*models.Modlist, error) {
+	data, err := os.ReadFile(mm.path(id))
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, fmt.Errorf("modlist not found")
+		}
+		return nil, err
+	}
+	var m models.Modlist
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil, err
+	}
+	return &m, nil
+}

backend/internal/services/modlist_parser.go

@@ -0,0 +1,116 @@
+package services
+
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"path"
+	"strings"
+
+	"arma3-web-server/internal/models"
+	"golang.org/x/net/html"
+)
+
+func ParseModlistHTML(r io.Reader) (string, []models.ModEntry, error) {
+	doc, err := html.Parse(r)
+	if err != nil {
+		return "", nil, fmt.Errorf("parse html: %w", err)
+	}
+
+	var mods []models.ModEntry
+	seen := map[string]bool{}
+
+	var walk func(*html.Node)
+	walk = func(n *html.Node) {
+		if n.Type == html.ElementNode && n.Data == "tr" {
+			if name, id, ok := extractModRow(n); ok && id != "" {
+				if !seen[id] {
+					seen[id] = true
+					mods = append(mods, models.ModEntry{
+						ID:      id,
+						Name:    cleanModName(name),
+						Enabled: true,
+					})
+				}
+			}
+		}
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(doc)
+
+	if mods == nil {
+		mods = []models.ModEntry{}
+	}
+	return "", mods, nil
+}
+
+func extractModRow(tr *html.Node) (name, id string, ok bool) {
+	var cells []*html.Node
+	for c := tr.FirstChild; c != nil; c = c.NextSibling {
+		if c.Type == html.ElementNode && c.Data == "td" {
+			cells = append(cells, c)
+		}
+	}
+	if len(cells) < 3 {
+		return "", "", false
+	}
+
+	name = extractText(cells[0])
+
+	for c := cells[2].FirstChild; c != nil; c = c.NextSibling {
+		if c.Type == html.ElementNode && c.Data == "a" {
+			id = extractWorkshopID(c)
+			break
+		}
+	}
+
+	if name == "" {
+		return "", "", false
+	}
+	return name, id, true
+}
+
+func extractText(n *html.Node) string {
+	var b strings.Builder
+	var walk func(*html.Node)
+	walk = func(n *html.Node) {
+		if n.Type == html.TextNode {
+			b.WriteString(n.Data)
+		}
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(n)
+	return strings.TrimSpace(b.String())
+}
+
+func extractWorkshopID(a *html.Node) string {
+	for _, attr := range a.Attr {
+		if attr.Key == "href" {
+			u, err := url.Parse(attr.Val)
+			if err != nil {
+				continue
+			}
+			return u.Query().Get("id")
+		}
+	}
+	return ""
+}
+
+func cleanModName(name string) string {
+	name = strings.TrimSpace(name)
+	name = strings.ReplaceAll(name, "/", "_")
+	name = strings.ReplaceAll(name, "\\", "_")
+	return name
+}
+
+func FileNameToModlistName(filename string) string {
+	ext := path.Ext(filename)
+	name := strings.TrimSuffix(filename, ext)
+	name = strings.ReplaceAll(name, "_", " ")
+	name = strings.ReplaceAll(name, "-", " ")
+	return name
+}

backend/internal/services/server_process.go

@@ -0,0 +1,267 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"arma3-web-server/internal/models"
+)
+
+type ProcessManager struct {
+	serverfileDir string
+	modsDir       string
+	cfgDir        string
+	profilesDir   string
+	settings      *SettingsManager
+	modlists      *ModlistManager
+	configs       *ConfigManager
+	streamer      *LogStreamer
+	proc          *runningProcess
+	mu            sync.RWMutex
+}
+
+type runningProcess struct {
+	cmd    *exec.Cmd
+	cancel context.CancelFunc
+	exited chan struct{}
+}
+
+func NewProcessManager(serverfileDir, modsDir, cfgDir, profilesDir string, settings *SettingsManager, modlists *ModlistManager, configs *ConfigManager, streamer *LogStreamer) *ProcessManager {
+	return &ProcessManager{
+		serverfileDir: serverfileDir,
+		modsDir:       modsDir,
+		cfgDir:        cfgDir,
+		profilesDir:   profilesDir,
+		settings:      settings,
+		modlists:      modlists,
+		configs:       configs,
+		streamer:      streamer,
+	}
+}
+
+func (pm *ProcessManager) ServerfileDir() string {
+	return pm.serverfileDir
+}
+
+func (pm *ProcessManager) ProfilesDir() string {
+	return pm.profilesDir
+}
+
+func (pm *ProcessManager) IsRunning() bool {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+	return pm.proc != nil
+}
+
+func (pm *ProcessManager) Start() error {
+	pm.mu.Lock()
+	if pm.proc != nil {
+		pm.mu.Unlock()
+		return fmt.Errorf("server already running")
+	}
+	pm.mu.Unlock()
+
+	s, err := pm.settings.Load()
+	if err != nil {
+		return fmt.Errorf("load settings: %w", err)
+	}
+
+	binName := "arma3server_x64"
+	if s.Platform == "windows" {
+		binName = "arma3server_x64.exe"
+	}
+	binPath := filepath.Join(pm.serverfileDir, binName)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	var cmd *exec.Cmd
+	if strings.Contains(s.ServerParameters, "%command%") {
+		full := strings.ReplaceAll(s.ServerParameters, "%command%", binPath)
+		parts := splitArgs(full)
+		if len(parts) == 0 {
+			cancel()
+			return fmt.Errorf("empty command after %%command%% substitution")
+		}
+		autoArgs := pm.buildAutoArgs(s)
+		cmd = exec.CommandContext(ctx, parts[0], append(parts[1:], autoArgs...)...)
+	} else {
+		cmd = exec.CommandContext(ctx, binPath, pm.buildArgs(s)...)
+	}
+	cmd.Dir = pm.serverfileDir
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		cancel()
+		return fmt.Errorf("stdout pipe: %w", err)
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		cancel()
+		return fmt.Errorf("stderr pipe: %w", err)
+	}
+
+	if err := cmd.Start(); err != nil {
+		cancel()
+		return fmt.Errorf("start: %w", err)
+	}
+
+	exited := make(chan struct{})
+	pm.mu.Lock()
+	pm.proc = &runningProcess{cmd: cmd, cancel: cancel, exited: exited}
+	pm.mu.Unlock()
+
+	go pm.streamer.Stream("server", stdout, "")
+	go pm.streamer.Stream("server", stderr, "")
+
+	go func() {
+		cmd.Wait()
+		pm.mu.Lock()
+		pm.proc = nil
+		pm.mu.Unlock()
+		close(exited)
+		pm.streamer.Broadcast("server", "[SERVER_PROCESS_EXITED]")
+	}()
+
+	return nil
+}
+
+func (pm *ProcessManager) Stop() error {
+	pm.mu.Lock()
+	rp := pm.proc
+	pm.mu.Unlock()
+
+	if rp == nil {
+		return fmt.Errorf("server not running")
+	}
+
+	rp.cancel()
+	<-rp.exited
+	return nil
+}
+
+func (pm *ProcessManager) Restart() error {
+	_ = pm.Stop()
+	return pm.Start()
+}
+
+func splitArgs(raw string) []string {
+	var args []string
+	for _, part := range strings.Fields(raw) {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			args = append(args, part)
+		}
+	}
+	return args
+}
+
+func (pm *ProcessManager) buildAutoArgs(s *models.ServerSettings) []string {
+	var args []string
+
+	if s.ActiveConfig != "" {
+		cfgPath := filepath.Join(pm.cfgDir, s.ActiveConfig+".cfg")
+		args = append(args, "-config="+cfgPath)
+	}
+
+	if s.ActiveModlist != "" {
+		modPath := pm.buildModPath(s.ActiveModlist)
+		if modPath != "" {
+			args = append(args, modPath)
+		}
+	}
+
+	if pm.profilesDir != "" && !hasArgPrefix(args, "-profiles=") {
+		args = append(args, "-profiles="+pm.profilesDir)
+	}
+
+	if s.IPPort != "" && !hasArgPrefix(args, "-port=") {
+		if _, portStr, err := net.SplitHostPort(s.IPPort); err == nil && portStr != "" {
+			args = append(args, "-port="+portStr)
+		}
+	}
+
+	return args
+}
+
+func (pm *ProcessManager) buildArgs(s *models.ServerSettings) []string {
+	args := splitArgs(s.ServerParameters)
+	args = append(args, pm.buildAutoArgs(s)...)
+	return args
+}
+
+func hasArgPrefix(args []string, prefix string) bool {
+	for _, a := range args {
+		if strings.HasPrefix(a, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+const workshopAppID = "107410"
+
+func (pm *ProcessManager) buildModPath(modlistID string) string {
+	ml, err := pm.modlists.Get(modlistID)
+	if err != nil {
+		return ""
+	}
+
+	var parts []string
+	for _, mod := range ml.Mods {
+		if !mod.Enabled {
+			continue
+		}
+		parts = append(parts, pm.resolveModPath(mod))
+	}
+
+	if len(parts) == 0 {
+		return ""
+	}
+	return "-mod=" + strings.Join(parts, ";")
+}
+
+func (pm *ProcessManager) resolveModPath(mod models.ModEntry) string {
+	if mod.Name != "" {
+		p := filepath.Join(pm.modsDir, "@"+mod.Name)
+		if _, err := os.Stat(p); err == nil {
+			return p
+		}
+	}
+
+	if mod.ID != "" {
+		p := filepath.Join(pm.serverfileDir, "steamapps", "workshop", "content", workshopAppID, mod.ID)
+		if _, err := os.Stat(p); err == nil {
+			return p
+		}
+	}
+
+	if mod.Name != "" {
+		return filepath.Join(pm.modsDir, "@"+mod.Name)
+	}
+	return ""
+}
+
+func (pm *ProcessManager) WriteUserconfigFiles(s *models.ServerSettings) error {
+	userconfigDir := filepath.Join(pm.serverfileDir, "userconfig")
+	if err := os.MkdirAll(userconfigDir, 0755); err != nil {
+		return err
+	}
+
+	files := map[string]string{
+		"cba_settings.sqf":         s.CBASettings,
+		"CfgAILevelPresets.sqf":    s.AILevelPresets,
+		"CfgDifficultyPresets.sqf": s.DifficultyPresets,
+	}
+	for name, content := range files {
+		path := filepath.Join(userconfigDir, name)
+		if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+			return fmt.Errorf("write %s: %w", name, err)
+		}
+	}
+	return nil
+}

backend/internal/services/settings.go

@@ -0,0 +1,66 @@
+package services
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"arma3-web-server/internal/models"
+)
+
+type SettingsManager struct {
+	path string
+	mu   sync.Mutex
+}
+
+func NewSettingsManager(dataDir string) *SettingsManager {
+	return &SettingsManager{
+		path: filepath.Join(dataDir, "settings.json"),
+	}
+}
+
+func (sm *SettingsManager) Load() (*models.ServerSettings, error) {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+
+	data, err := os.ReadFile(sm.path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return sm.defaults(), nil
+		}
+		return nil, err
+	}
+
+	var s models.ServerSettings
+	if err := json.Unmarshal(data, &s); err != nil {
+		return nil, err
+	}
+	return &s, nil
+}
+
+func (sm *SettingsManager) Save(s *models.ServerSettings) error {
+	sm.mu.Lock()
+	defer sm.mu.Unlock()
+
+	s.UpdatedAt = time.Now().UTC()
+	data, err := json.MarshalIndent(s, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(sm.path, data, 0644)
+}
+
+func (sm *SettingsManager) defaults() *models.ServerSettings {
+	return &models.ServerSettings{
+		IPPort:            "0.0.0.0:2302",
+		ServerParameters:  "-server -world=empty -loadMissionToMemory -noPause",
+		SteamBranch:       "stable",
+		SteamUser:         "anonymous",
+		Platform:          "linux",
+		ActiveConfig:      "",
+		ActiveModlist:     "",
+		UpdatedAt:         time.Now().UTC(),
+	}
+}

backend/internal/services/steamcmd.go

@@ -0,0 +1,142 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+func CheckWorkshopMod(serverfileDir, modID string) bool {
+	if modID == "" {
+		return false
+	}
+	p := filepath.Join(serverfileDir, "steamapps", "workshop", "content", "107410", modID)
+	fi, err := os.Stat(p)
+	return err == nil && fi.IsDir()
+}
+
+const arma3AppID = "233780"
+
+type SteamCmdManager struct {
+	serverfileDir string
+	streamer      *LogStreamer
+	mu            sync.Mutex
+	cancel        context.CancelFunc
+	running       bool
+}
+
+func NewSteamCmdManager(serverfileDir string, streamer *LogStreamer) *SteamCmdManager {
+	return &SteamCmdManager{
+		serverfileDir: serverfileDir,
+		streamer:      streamer,
+	}
+}
+
+func (s *SteamCmdManager) IsRunning() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.running
+}
+
+func (s *SteamCmdManager) UpdateGame(branch, user string) error {
+	s.mu.Lock()
+	if s.running {
+		s.mu.Unlock()
+		return fmt.Errorf("steamcmd already running")
+	}
+	s.mu.Unlock()
+
+	args := []string{
+		"+force_install_dir", s.serverfileDir,
+		"+login", user,
+		"+app_update", arma3AppID,
+	}
+	if branch != "" && branch != "stable" {
+		args = append(args, "-beta", branch)
+	}
+	args = append(args, "validate", "+quit")
+
+	return s.run("Game update", args)
+}
+
+func (s *SteamCmdManager) DownloadMod(modID string) error {
+	return s.DownloadMods([]string{modID})
+}
+
+func (s *SteamCmdManager) DownloadMods(modIDs []string) error {
+	s.mu.Lock()
+	if s.running {
+		s.mu.Unlock()
+		return fmt.Errorf("steamcmd already running")
+	}
+	s.mu.Unlock()
+
+	if len(modIDs) == 0 {
+		return fmt.Errorf("no mod ids provided")
+	}
+
+	args := []string{
+		"+force_install_dir", s.serverfileDir,
+		"+login", "anonymous",
+	}
+	for _, id := range modIDs {
+		args = append(args, "+workshop_download_item", "107410", id)
+	}
+	args = append(args, "+quit")
+
+	label := fmt.Sprintf("Download %d mod(s)", len(modIDs))
+	return s.run(label, args)
+}
+
+const steamcmdTimeout = 10 * time.Minute
+
+func (s *SteamCmdManager) run(label string, args []string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), steamcmdTimeout)
+
+	s.streamer.Broadcast("steamcmd", "[STEAMCMD] "+label+" starting...")
+
+	cmd := exec.CommandContext(ctx, "steamcmd", args...)
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		cancel()
+		return fmt.Errorf("stdout pipe: %w", err)
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		cancel()
+		return fmt.Errorf("stderr pipe: %w", err)
+	}
+
+	if err := cmd.Start(); err != nil {
+		cancel()
+		return fmt.Errorf("start steamcmd: %w", err)
+	}
+
+	s.mu.Lock()
+	s.running = true
+	s.cancel = cancel
+	s.mu.Unlock()
+
+	go s.streamer.Stream("steamcmd", stdout, "")
+	go s.streamer.Stream("steamcmd", stderr, "")
+
+	go func() {
+		err := cmd.Wait()
+		s.mu.Lock()
+		s.running = false
+		s.cancel = nil
+		s.mu.Unlock()
+		if err == nil {
+			s.streamer.Broadcast("steamcmd", "[STEAMCMD] SUCCESS: "+label+" finished")
+		} else {
+			s.streamer.Broadcast("steamcmd", "[STEAMCMD] ERROR: "+label+" failed: "+err.Error())
+		}
+	}()
+
+	return nil
+}