Fixes

README.md

@@ -153,6 +153,69 @@ are ignored if present in a config file (unknown keys do not cause errors):
 `password_authentication`, `dh_file`, `stats_update_period`,
 `stats_db_update_period`, `grpc.enabled`, `task_manager.update_period`
 
+## Command placeholders and server variables
+
+The daemon renders the game mod start command and the `scripts.*` wrappers
+itself. Every `{placeholder}` is replaced once, in a single pass, so a
+substituted value is never expanded again.
+
+### Built-in placeholders
+
+| Placeholder                             | Value
+|-----------------------------------------|------------
+| `{dir}`                                 | Absolute server directory (`work_path` + the server `dir`)
+| `{work_dir}`                            | Absolute process working directory (see below)
+| `{uuid}`, `{uuid_short}`, `{id}`        | Server identifiers from the panel
+| `{ip}`, `{host}`                        | Server IP
+| `{port}`, `{SERVER_PORT}`, `{PORT}`     | Connect port
+| `{query_port}`, `{rcon_port}`           | Query and RCON ports
+| `{rcon_password}`                       | RCON password
+| `{user}`                                | System user the server runs as
+| `{game}`                                | Game start code; a mod variable named `game` wins (see below)
+| `{node_work_path}`, `{node_tools_path}` | Daemon `work_path` and its `tools` subdirectory
+| `{command}`                             | Wrapper templates only: the tokens of the server command
+
+### Game mod variables
+
+Every variable of the game mod (the `vars` list in the games catalogue) is a
+placeholder too, in three spellings: the name as the catalogue stores it and its
+all-lowercase and all-uppercase forms, so a variable `maxplayers` fills both
+`{maxplayers}` and `{MAXPLAYERS}`. A mixed-case `{MaxPlayers}` is substituted
+only when the catalogue spells the name that way. The value is resolved in this
+order, the last one wins:
+
+1. the variable default from the game mod;
+2. the server variables (`vars` on the admin server page);
+3. the server settings (the server settings page).
+
+A built-in placeholder wins over a variable of the same name, except `{game}`:
+the catalogue defines it as a mod variable (Quake 2 starts with
+`+set game {game}` and a variable `game=baseq2`), so the variable wins and the
+game start code is only the fallback.
+
+Values are substituted exactly as the panel stores them. Since GameAP 4.5 the
+panel validates typed variables (`int`, `float`, `bool`, `select`, ...) and
+stores the canonical text: a `bool` variable is its `true_value`/`false_value`
+(`1`/`0` by default), a number is its decimal text. The daemon never parses or
+converts a value.
+
+Templates are tokenized first and placeholders are substituted into the
+individual tokens, so a value never splits into several arguments and shell
+metacharacters in a value are harmless. An empty value yields an empty
+argument: `+sv_setsteamaccount {server_token}` becomes
+`+sv_setsteamaccount ""`. A flag-style `bool` variable with an empty
+`false_value` should therefore be embedded in a larger token
+(`--flag={var}`) rather than used as a standalone `{var}`.
+
+### Environment
+
+The merged variables (same order as above) are exported to the game server
+process as environment variables. The name is upper-cased, `-` and spaces
+become `_`, other characters are dropped (`max-players` becomes
+`MAX_PLAYERS`). Then `HOME` is set when a `home_dir` is configured, and finally
+`SERVER_PORT`, `PORT`, `QUERY_PORT` and `RCON_PORT`, which a variable cannot
+override.
+
 ## Game server working directory
 
 By default a game server process starts in the server directory

internal/app/domain/commands.go

@@ -109,6 +109,10 @@ func ReplaceShortCodes(commandTemplate string, cfg workDirReader, server *Server
 // {dir} is the server directory and {work_dir} the directory the process runs
 // in, even when a server variable is called work_dir.
 //
+// {game} is the one exception: the games catalogue defines it as a mod variable
+// (Quake 2 starts with "+set game {game}" and a variable game=baseq2), so a
+// variable named game wins and the game start code is only the fallback.
+//
 // It fails when the configured work_dir is not a relative path inside the
 // server directory; the same value is rejected again before the server starts.
 func newServerReplacer(cfg workDirReader, server *Server, paths CommandPaths) (*strings.Replacer, error) {
@@ -148,7 +152,6 @@ func newServerReplacer(cfg workDirReader, server *Server, paths CommandPaths) (*
 		"{query_port}", strconv.Itoa(server.QueryPort()),
 		"{rcon_port}", strconv.Itoa(server.RCONPort()),
 		"{rcon_password}", server.RCONPassword(),
-		"{game}", server.Game().StartCode,
 		"{user}", server.User(),
 		"{node_work_path}", cfg.WorkDir(),
 		"{node_tools_path}", cfg.WorkDir()+"/tools",
@@ -162,5 +165,7 @@ func newServerReplacer(cfg workDirReader, server *Server, paths CommandPaths) (*
 		)
 	}
 
+	pairs = append(pairs, "{game}", server.Game().StartCode)
+
 	return strings.NewReplacer(pairs...), nil
 }

internal/app/domain/commands_args_test.go

@@ -170,3 +170,23 @@ func TestBuildCommandArgsWithPaths_StillRejectsInvalidWorkDir(t *testing.T) {
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "path is outside work directory")
 }
+
+func TestBuildCommandArgs_EmptyValueStaysAnEmptyArgument(t *testing.T) {
+	// The games catalogue relies on it: "+sv_setsteamaccount {server_token}"
+	// with an empty token must still hand the server an (empty) argument.
+	cfg := fakeWorkDirReader{workDir: "/work-path"}
+	server := newTestServerForVars(
+		[]GameModVarTemplate{{Key: "server_token", DefaultValue: ""}},
+		nil,
+		nil,
+	)
+
+	args, err := BuildCommandArgs(
+		cfg, server,
+		"{command}",
+		"./srcds_run +sv_setsteamaccount {server_token} +map de_dust2",
+	)
+
+	require.NoError(t, err)
+	assert.Equal(t, []string{"./srcds_run", "+sv_setsteamaccount", "", "+map", "de_dust2"}, args)
+}

internal/app/domain/commands_test.go

@@ -169,3 +169,52 @@ func TestMakeFullCommand_InvalidWorkDirReturnsError(t *testing.T) {
 	assert.Contains(t, err.Error(), `invalid work_dir "/abs" from server vars`)
 	assert.Contains(t, err.Error(), "must be a path relative to the server directory")
 }
+
+func TestReplaceShortCodes_GamePlaceholder(t *testing.T) {
+	cfg := fakeWorkDirReader{workDir: "/work-path"}
+
+	tests := []struct {
+		name        string
+		game        Game
+		gameModVars []GameModVarTemplate
+		settings    Settings
+		expected    string
+	}{
+		{
+			name:        "mod_variable_wins_over_start_code",
+			game:        Game{StartCode: "q2"},
+			gameModVars: []GameModVarTemplate{{Key: "game", DefaultValue: "baseq2"}},
+			expected:    "+set game baseq2",
+		},
+		{
+			name:        "server_setting_overrides_the_variable_default",
+			game:        Game{StartCode: "q2"},
+			gameModVars: []GameModVarTemplate{{Key: "game", DefaultValue: "baseq2"}},
+			settings:    Settings{"game": "ctf"},
+			expected:    "+set game ctf",
+		},
+		{
+			name:     "start_code_is_the_fallback",
+			game:     Game{StartCode: "cstrike"},
+			expected: "+set game cstrike",
+		},
+		{
+			// The panel sends no start code over gRPC, so a mod without a game
+			// variable renders an empty value.
+			name:     "empty_without_start_code_and_variable",
+			game:     Game{},
+			expected: "+set game ",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := newTestServerForVarsWithGame(tt.game, tt.gameModVars, nil, tt.settings)
+
+			result, err := ReplaceShortCodes("+set game {game}", cfg, server)
+
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}

internal/app/domain/game.go

@@ -54,43 +54,8 @@ type SteamSettings struct {
 }
 
 type GameModVarTemplate struct {
-	Key          string
-	DefaultValue string
-}
-
-func (g *GameModVarTemplate) UnmarshalJSON(bytes []byte) error {
-	v := struct {
-		Var      string      `json:"var"`
-		Default  interface{} `json:"default"`
-		Info     string      `json:"info"`
-		AdminVar bool        `json:"admin_var"`
-	}{}
-
-	err := json.Unmarshal(bytes, &v)
-	if err != nil {
-		return err
-	}
-
-	g.Key = v.Var
-
-	switch defaultValue := v.Default.(type) {
-	case string:
-		g.DefaultValue = defaultValue
-	case int:
-		g.DefaultValue = strconv.Itoa(defaultValue)
-	case float64:
-		g.DefaultValue = strconv.Itoa(int(defaultValue))
-	case bool:
-		if v.Default.(bool) {
-			g.DefaultValue = "1"
-		} else {
-			g.DefaultValue = "0"
-		}
-	default:
-		g.DefaultValue = ""
-	}
-
-	return nil
+	Key          string `json:"var"`
+	DefaultValue string `json:"default"`
 }
 
 type GameMod struct {

internal/app/domain/server_test.go

@@ -13,6 +13,15 @@ func newTestServerForVars(
 	gameModVars []GameModVarTemplate,
 	vars map[string]string,
 	settings Settings,
+) *Server {
+	return newTestServerForVarsWithGame(Game{StartCode: "game"}, gameModVars, vars, settings)
+}
+
+func newTestServerForVarsWithGame(
+	game Game,
+	gameModVars []GameModVarTemplate,
+	vars map[string]string,
+	settings Settings,
 ) *Server {
 	return NewServer(
 		1,
@@ -22,7 +31,7 @@ func newTestServerForVars(
 		"test",
 		"test-uuid",
 		"test",
-		Game{StartCode: "game"},
+		game,
 		GameMod{Vars: gameModVars},
 		"127.0.0.1",
 		27015,

internal/app/grpc/converters_test.go

@@ -0,0 +1,112 @@
+package grpc
+
+import (
+	"testing"
+
+	"github.com/gameap/daemon/internal/app/domain"
+	pb "github.com/gameap/gameap/pkg/proto"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProtoGameModToDomain_KeepsVarDefaultsVerbatim(t *testing.T) {
+	// The panel canonicalizes every variable before it is sent: a bool is its
+	// true_value/false_value text, a number is its decimal text. Nothing of it
+	// may be reinterpreted here.
+	protoVars := []*pb.GameModVar{
+		{Var: "ase", Default: "1", Info: "All Seeing Eye", AdminVar: true},
+		{Var: "pvp", Default: "0"},
+		{Var: "debug", Default: "true"},
+		{Var: "hardcore", Default: "false"},
+		{Var: "code", Default: "007"},
+		{Var: "ratio", Default: "1.50"},
+		{Var: "password", Default: ""},
+		{Var: "game", Default: "baseq2"},
+		{Var: "SERVER_TOKEN", Default: "abc"},
+	}
+
+	gameMod := ProtoGameModToDomain(&pb.GameMod{Id: 10, GameCode: "q2", Name: "Default", Vars: protoVars})
+
+	expected := make([]domain.GameModVarTemplate, 0, len(protoVars))
+	for _, v := range protoVars {
+		expected = append(expected, domain.GameModVarTemplate{Key: v.Var, DefaultValue: v.Default})
+	}
+
+	assert.Equal(t, expected, gameMod.Vars)
+}
+
+func TestParseProtoSettings(t *testing.T) {
+	tests := []struct {
+		name     string
+		settings []*pb.ServerSetting
+		expected domain.Settings
+	}{
+		{
+			name:     "nil_slice_means_no_settings",
+			settings: nil,
+			expected: nil,
+		},
+		{
+			name:     "empty_slice_means_no_settings",
+			settings: []*pb.ServerSetting{},
+			expected: nil,
+		},
+		{
+			name: "values_are_kept_verbatim",
+			settings: []*pb.ServerSetting{
+				{Name: "ase", Value: "0"},
+				{Name: "code", Value: "007"},
+				{Name: "ratio", Value: "1.50"},
+				{Name: "password", Value: ""},
+				{Name: "autostart", Value: "true"},
+			},
+			expected: domain.Settings{
+				"ase":       "0",
+				"code":      "007",
+				"ratio":     "1.50",
+				"password":  "",
+				"autostart": "true",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, parseProtoSettings(tt.settings))
+		})
+	}
+}
+
+func TestParseVarsJSON(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected map[string]string
+	}{
+		{
+			name:     "empty_input",
+			input:    "",
+			expected: map[string]string{},
+		},
+		{
+			name:     "values_are_kept_verbatim",
+			input:    `{"map":"q2dm1","code":"007","empty":""}`,
+			expected: map[string]string{"map": "q2dm1", "code": "007", "empty": ""},
+		},
+		{
+			name:     "invalid_json_yields_no_vars",
+			input:    `{"map":`,
+			expected: map[string]string{},
+		},
+		{
+			name:     "non_string_value_yields_no_vars",
+			input:    `{"maxplayers": 32}`,
+			expected: map[string]string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, parseVarsJSON(tt.input))
+		})
+	}
+}