server_test.go

package server

import (
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"
	"testing"

	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type nullWriter struct{}

func (w *nullWriter) Write(p []byte) (int, error) {
	return len(p), nil
}

// setupCommandOutput configures a cobra command to use a null writer for output capture.
func setupCommandOutput(t *testing.T, cmd *cobra.Command) {
	t.Helper()

	cmd.SetOut(&nullWriter{})
	cmd.SetErr(&nullWriter{})
}

func TestParseAgentType(t *testing.T) {
	tests := []struct {
		firstArg     string
		agentTypeVar string
		want         AgentType
	}{
		{
			firstArg:     "",
			agentTypeVar: "",
			want:         AgentTypeCustom,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "",
			want:         AgentTypeClaude,
		},
		{
			firstArg:     "gemini",
			agentTypeVar: "",
			want:         AgentTypeGemini,
		},
		{
			firstArg:     "copilot",
			agentTypeVar: "",
			want:         AgentTypeCopilot,
		},
		{
			firstArg:     "cursor-agent",
			agentTypeVar: "",
			want:         AgentTypeCursor,
		},
		{
			firstArg:     "cursor",
			agentTypeVar: "",
			want:         AgentTypeCursor,
		},
		{
			firstArg:     "amazonq",
			agentTypeVar: "",
			want:         AgentTypeAmazonQ,
		},
		{
			firstArg:     "q",
			agentTypeVar: "",
			want:         AgentTypeAmazonQ,
		},
		{
			firstArg:     "opencode",
			agentTypeVar: "",
			want:         AgentTypeOpencode,
		},
		{
			firstArg:     "auggie",
			agentTypeVar: "",
			want:         AgentTypeAuggie,
		},
		{
			firstArg:     "amp",
			agentTypeVar: "",
			want:         AgentTypeAmp,
		},
		{
			firstArg:     "goose",
			agentTypeVar: "",
			want:         AgentTypeGoose,
		},
		{
			firstArg:     "aider",
			agentTypeVar: "",
			want:         AgentTypeAider,
		},
		{
			firstArg:     "whatever",
			agentTypeVar: "",
			want:         AgentTypeCustom,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "goose",
			want:         AgentTypeGoose,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "copilot",
			want:         AgentTypeCopilot,
		},
		{
			firstArg:     "goose",
			agentTypeVar: "claude",
			want:         AgentTypeClaude,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "gemini",
			want:         AgentTypeGemini,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "amazonq",
			want:         AgentTypeAmazonQ,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "q",
			want:         AgentTypeAmazonQ,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "opencode",
			want:         AgentTypeOpencode,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "cursor-agent",
			want:         AgentTypeCursor,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "cursor",
			want:         AgentTypeCursor,
		},
		{
			firstArg:     "claude",
			agentTypeVar: "auggie",
			want:         AgentTypeAuggie,
		},
		{
			firstArg:     "aider",
			agentTypeVar: "claude",
			want:         AgentTypeClaude,
		},
		{
			firstArg:     "aider",
			agentTypeVar: "custom",
			want:         AgentTypeCustom,
		},
	}

	for _, test := range tests {
		t.Run(fmt.Sprintf("%s-%s-%s", test.firstArg, test.agentTypeVar, test.want), func(t *testing.T) {
			got, err := parseAgentType(test.firstArg, test.agentTypeVar)
			require.NoError(t, err)
			require.Equal(t, test.want, got)
		})
	}

	t.Run("invalid agent type", func(t *testing.T) {
		_, err := parseAgentType("claude", "invalid")
		require.Error(t, err)
	})
}

// Test helper to isolate viper config between tests
func isolateViper(t *testing.T) {
	// Save current state
	oldConfig := viper.AllSettings()

	// Reset viper
	viper.Reset()

	// Clear AGENTAPI_ env vars
	var agentapiEnvs []string
	for _, env := range os.Environ() {
		if strings.HasPrefix(env, "AGENTAPI_") {
			parts := strings.SplitN(env, "=", 2)
			agentapiEnvs = append(agentapiEnvs, parts[0])
			if err := os.Unsetenv(parts[0]); err != nil {
				t.Fatalf("Failed to unset env var %s: %v", parts[0], err)
			}
		}
	}

	t.Cleanup(func() {
		// Restore state
		viper.Reset()
		for key, value := range oldConfig {
			viper.Set(key, value)
		}

		// Restore env vars
		for _, key := range agentapiEnvs {
			if val := os.Getenv(key); val != "" {
				if err := os.Setenv(key, val); err != nil {
					t.Fatalf("Failed to set env var %s: %v", key, err)
				}
			}
		}
	})
}

// Test configuration values via ServerCmd execution
func TestServerCmd_AllArgs_Defaults(t *testing.T) {
	tests := []struct {
		name     string
		flag     string
		expected any
		getter   func() any
	}{
		{"type default", FlagType, "", func() any { return viper.GetString(FlagType) }},
		{"port default", FlagPort, 3284, func() any { return viper.GetInt(FlagPort) }},
		{"print-openapi default", FlagPrintOpenAPI, false, func() any { return viper.GetBool(FlagPrintOpenAPI) }},
		{"chat-base-path default", FlagChatBasePath, "/chat", func() any { return viper.GetString(FlagChatBasePath) }},
		{"term-width default", FlagTermWidth, uint16(80), func() any { return viper.GetUint16(FlagTermWidth) }},
		{"term-height default", FlagTermHeight, uint16(1000), func() any { return viper.GetUint16(FlagTermHeight) }},
		{"allowed-hosts default", FlagAllowedHosts, []string{"localhost", "127.0.0.1", "[::1]"}, func() any { return viper.GetStringSlice(FlagAllowedHosts) }},
		{"allowed-origins default", FlagAllowedOrigins, []string{"http://localhost:3284", "http://localhost:3000", "http://localhost:3001"}, func() any { return viper.GetStringSlice(FlagAllowedOrigins) }},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isolateViper(t)
			serverCmd := CreateServerCmd()
			setupCommandOutput(t, serverCmd)
			// Execute with --exit to get defaults
			serverCmd.SetArgs([]string{"--exit", "dummy-command"})
			if err := serverCmd.Execute(); err != nil {
				t.Fatalf("Failed to execute server command: %v", err)
			}

			assert.Equal(t, tt.expected, tt.getter())
		})
	}
}

func TestServerCmd_AllEnvVars(t *testing.T) {
	tests := []struct {
		name     string
		envVar   string
		envValue string
		expected any
		getter   func() any
	}{
		{"AGENTAPI_TYPE", "AGENTAPI_TYPE", "claude", "claude", func() any { return viper.GetString(FlagType) }},
		{"AGENTAPI_PORT", "AGENTAPI_PORT", "8080", 8080, func() any { return viper.GetInt(FlagPort) }},
		{"AGENTAPI_PRINT_OPENAPI", "AGENTAPI_PRINT_OPENAPI", "true", true, func() any { return viper.GetBool(FlagPrintOpenAPI) }},
		{"AGENTAPI_CHAT_BASE_PATH", "AGENTAPI_CHAT_BASE_PATH", "/api", "/api", func() any { return viper.GetString(FlagChatBasePath) }},
		{"AGENTAPI_TERM_WIDTH", "AGENTAPI_TERM_WIDTH", "120", uint16(120), func() any { return viper.GetUint16(FlagTermWidth) }},
		{"AGENTAPI_TERM_HEIGHT", "AGENTAPI_TERM_HEIGHT", "500", uint16(500), func() any { return viper.GetUint16(FlagTermHeight) }},
		{"AGENTAPI_ALLOWED_HOSTS", "AGENTAPI_ALLOWED_HOSTS", "localhost example.com", []string{"localhost", "example.com"}, func() any { return viper.GetStringSlice(FlagAllowedHosts) }},
		{"AGENTAPI_ALLOWED_ORIGINS", "AGENTAPI_ALLOWED_ORIGINS", "https://example.com http://localhost:3000", []string{"https://example.com", "http://localhost:3000"}, func() any { return viper.GetStringSlice(FlagAllowedOrigins) }},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isolateViper(t)
			t.Setenv(tt.envVar, tt.envValue)

			serverCmd := CreateServerCmd()
			setupCommandOutput(t, serverCmd)
			serverCmd.SetArgs([]string{"--exit", "dummy-command"})
			if err := serverCmd.Execute(); err != nil {
				t.Fatalf("Failed to execute server command: %v", err)
			}

			assert.Equal(t, tt.expected, tt.getter())
		})
	}
}

func TestServerCmd_ArgsPrecedenceOverEnv(t *testing.T) {
	tests := []struct {
		name     string
		envVar   string
		envValue string
		args     []string
		expected any
		getter   func() any
	}{
		{
			"type: CLI overrides env",
			"AGENTAPI_TYPE", "goose",
			[]string{"--type", "claude"},
			"claude",
			func() any { return viper.GetString(FlagType) },
		},
		{
			"port: CLI overrides env",
			"AGENTAPI_PORT", "8080",
			[]string{"--port", "9090"},
			9090,
			func() any { return viper.GetInt(FlagPort) },
		},
		{
			"print-openapi: CLI overrides env",
			"AGENTAPI_PRINT_OPENAPI", "false",
			[]string{"--print-openapi"},
			true,
			func() any { return viper.GetBool(FlagPrintOpenAPI) },
		},
		{
			"chat-base-path: CLI overrides env",
			"AGENTAPI_CHAT_BASE_PATH", "/env-path",
			[]string{"--chat-base-path", "/cli-path"},
			"/cli-path",
			func() any { return viper.GetString(FlagChatBasePath) },
		},
		{
			"term-width: CLI overrides env",
			"AGENTAPI_TERM_WIDTH", "100",
			[]string{"--term-width", "150"},
			uint16(150),
			func() any { return viper.GetUint16(FlagTermWidth) },
		},
		{
			"term-height: CLI overrides env",
			"AGENTAPI_TERM_HEIGHT", "500",
			[]string{"--term-height", "600"},
			uint16(600),
			func() any { return viper.GetUint16(FlagTermHeight) },
		},
		{
			"allowed-origins: CLI overrides env",
			"AGENTAPI_ALLOWED_ORIGINS", "https://env-example.com http://localhost:3000",
			[]string{"--allowed-origins", "https://cli-example.com"},
			[]string{"https://cli-example.com"},
			func() any { return viper.GetStringSlice(FlagAllowedOrigins) },
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isolateViper(t)
			t.Setenv(tt.envVar, tt.envValue)

			args := append(tt.args, "--exit", "dummy-command")
			serverCmd := CreateServerCmd()
			setupCommandOutput(t, serverCmd)
			serverCmd.SetArgs(args)
			if err := serverCmd.Execute(); err != nil {
				t.Fatalf("Failed to execute server command: %v", err)
			}

			assert.Equal(t, tt.expected, tt.getter())
		})
	}
}

func TestMixed_ConfigurationScenarios(t *testing.T) {
	t.Run("some env, some cli, some defaults", func(t *testing.T) {
		isolateViper(t)

		// Set some env vars
		t.Setenv("AGENTAPI_TYPE", "goose")
		t.Setenv("AGENTAPI_TERM_WIDTH", "120")

		// Set some CLI args
		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--port", "9999", "--print-openapi", "--exit", "dummy-command"})
		if err := serverCmd.Execute(); err != nil {
			t.Fatalf("Failed to execute server command: %v", err)
		}

		// Verify mixed configuration
		assert.Equal(t, "goose", viper.GetString(FlagType))            // from env
		assert.Equal(t, 9999, viper.GetInt(FlagPort))                  // from CLI
		assert.Equal(t, true, viper.GetBool(FlagPrintOpenAPI))         // from CLI
		assert.Equal(t, "/chat", viper.GetString(FlagChatBasePath))    // default
		assert.Equal(t, uint16(120), viper.GetUint16(FlagTermWidth))   // from env
		assert.Equal(t, uint16(1000), viper.GetUint16(FlagTermHeight)) // default
	})
}

func TestServerCmd_AllowedHosts(t *testing.T) {
	tests := []struct {
		name        string
		env         map[string]string
		args        []string
		expectedErr string
		expected    []string // only checked if expectedErr is empty
	}{
		// Environment variable scenarios (space-separated format)
		{
			name:     "env: single valid host",
			env:      map[string]string{"AGENTAPI_ALLOWED_HOSTS": "localhost"},
			args:     []string{},
			expected: []string{"localhost"},
		},
		{
			name:     "env: multiple valid hosts space-separated",
			env:      map[string]string{"AGENTAPI_ALLOWED_HOSTS": "localhost example.com 192.168.1.1"},
			args:     []string{},
			expected: []string{"localhost", "example.com", "192.168.1.1"},
		},
		{
			name:     "env: host with tab",
			env:      map[string]string{"AGENTAPI_ALLOWED_HOSTS": "localhost\texample.com"},
			args:     []string{},
			expected: []string{"localhost", "example.com"},
		},
		// CLI flag scenarios (comma-separated format)
		{
			name:     "flag: single valid host",
			args:     []string{"--allowed-hosts", "localhost"},
			expected: []string{"localhost"},
		},
		{
			name:     "flag: multiple valid hosts comma-separated",
			args:     []string{"--allowed-hosts", "localhost,example.com,192.168.1.1"},
			expected: []string{"localhost", "example.com", "192.168.1.1"},
		},
		{
			name:     "flag: multiple valid hosts with multiple flags",
			args:     []string{"--allowed-hosts", "localhost", "--allowed-hosts", "example.com"},
			expected: []string{"localhost", "example.com"},
		},
		{
			name:     "flag: host with newline",
			args:     []string{"--allowed-hosts", "localhost\n"},
			expected: []string{"localhost"},
		},
		{
			name:     "flag: ipv6 bracketed literal",
			args:     []string{"--allowed-hosts", "[2001:db8::1]"},
			expected: []string{"[2001:db8::1]"},
		},

		// Mixed scenarios (env + flag precedence)
		{
			name:     "mixed: flag overrides env",
			env:      map[string]string{"AGENTAPI_ALLOWED_HOSTS": "localhost"},
			args:     []string{"--allowed-hosts", "override.com"},
			expected: []string{"override.com"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isolateViper(t)

			// Set environment variables if provided
			for key, value := range tt.env {
				t.Setenv(key, value)
			}

			serverCmd := CreateServerCmd()
			setupCommandOutput(t, serverCmd)
			serverCmd.SetArgs(append(tt.args, "--exit", "dummy-command"))
			err := serverCmd.Execute()

			if tt.expectedErr != "" {
				require.Error(t, err)
				assert.Contains(t, err.Error(), tt.expectedErr)
			} else {
				require.NoError(t, err)
				assert.Equal(t, tt.expected, viper.GetStringSlice(FlagAllowedHosts))
			}
		})
	}
}

func TestServerCmd_StatePersistenceFlags(t *testing.T) {
	// NOTE: These tests use --exit flag to test flag parsing and defaults.
	// Runtime validation that happens in runServer (e.g., "--load-state requires --state-file")
	// would call os.Exit(1) which terminates the test process, so those validations
	// are tested through integration/E2E tests instead.

	t.Run("state-file with defaults", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--state-file", "/tmp/state.json", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/state.json", viper.GetString(FlagStateFile))
		// load-state and save-state default to true when state-file is set (validated in runServer)
	})

	t.Run("state-file with explicit load-state=false", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--state-file", "/tmp/state.json", "--load-state=false", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/state.json", viper.GetString(FlagStateFile))
		assert.Equal(t, false, viper.GetBool(FlagLoadState))
	})

	t.Run("state-file with explicit save-state=false", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--state-file", "/tmp/state.json", "--save-state=false", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/state.json", viper.GetString(FlagStateFile))
		assert.Equal(t, false, viper.GetBool(FlagSaveState))
	})

	t.Run("state-file with explicit load-state=true and save-state=true", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{
			"--state-file", "/tmp/state.json",
			"--load-state=true",
			"--save-state=true",
			"--exit", "dummy-command",
		})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/state.json", viper.GetString(FlagStateFile))
		assert.Equal(t, true, viper.GetBool(FlagLoadState))
		assert.Equal(t, true, viper.GetBool(FlagSaveState))
	})

	t.Run("load-state flag can be parsed", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--load-state", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		// Flag is parsed correctly (validation happens in runServer)
		assert.Equal(t, true, viper.GetBool(FlagLoadState))
	})

	t.Run("save-state flag can be parsed", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--save-state", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		// Flag is parsed correctly (validation happens in runServer)
		assert.Equal(t, true, viper.GetBool(FlagSaveState))
	})

	t.Run("pid-file can be set independently", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--pid-file", "/tmp/server.pid", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/server.pid", viper.GetString(FlagPidFile))
	})

	t.Run("state-file and pid-file can be set together", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{
			"--state-file", "/tmp/state.json",
			"--pid-file", "/tmp/server.pid",
			"--exit", "dummy-command",
		})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/tmp/state.json", viper.GetString(FlagStateFile))
		assert.Equal(t, "/tmp/server.pid", viper.GetString(FlagPidFile))
	})
}

func TestPIDFileOperations(t *testing.T) {
	discardLogger := slog.New(slog.NewTextHandler(io.Discard, nil))

	t.Run("writePIDFile creates file with process ID", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/test.pid"

		err := writePIDFile(pidFile, discardLogger)
		require.NoError(t, err)

		// Verify file exists
		_, err = os.Stat(pidFile)
		require.NoError(t, err)

		// Verify content contains current PID
		data, err := os.ReadFile(pidFile)
		require.NoError(t, err)

		expectedPID := fmt.Sprintf("%d\n", os.Getpid())
		assert.Equal(t, expectedPID, string(data))
	})

	t.Run("writePIDFile creates directory if not exists", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/nested/deep/test.pid"

		err := writePIDFile(pidFile, discardLogger)
		require.NoError(t, err)

		// Verify file exists
		_, err = os.Stat(pidFile)
		require.NoError(t, err)

		// Verify directory was created
		_, err = os.Stat(tmpDir + "/nested/deep")
		require.NoError(t, err)
	})

	t.Run("writePIDFile overwrites existing file", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/test.pid"

		// Write a non-numeric PID so strconv.Atoi fails and the liveness
		// check is skipped, avoiding flakes when a real PID matches.
		err := os.WriteFile(pidFile, []byte("not-a-pid\n"), 0o644)
		require.NoError(t, err)

		// Overwrite with current PID
		err = writePIDFile(pidFile, discardLogger)
		require.NoError(t, err)

		// Verify content is updated
		data, err := os.ReadFile(pidFile)
		require.NoError(t, err)

		expectedPID := fmt.Sprintf("%d\n", os.Getpid())
		assert.Equal(t, expectedPID, string(data))
	})

	t.Run("writePIDFile detects running process", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/test.pid"

		// Write the current process PID so isProcessRunning returns true.
		err := os.WriteFile(pidFile, []byte(fmt.Sprintf("%d\n", os.Getpid())), 0o644)
		require.NoError(t, err)

		err = writePIDFile(pidFile, discardLogger)
		require.Error(t, err)
		assert.Contains(t, err.Error(), "another instance is already running")
	})

	t.Run("cleanupPIDFile removes file", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/test.pid"

		// Create PID file with current process PID so ownership check passes
		err := os.WriteFile(pidFile, []byte(fmt.Sprintf("%d\n", os.Getpid())), 0o644)
		require.NoError(t, err)

		// Cleanup
		cleanupPIDFile(pidFile, discardLogger)

		// Verify file is removed
		_, err = os.Stat(pidFile)
		assert.True(t, os.IsNotExist(err))
	})

	t.Run("cleanupPIDFile handles non-existent file", func(t *testing.T) {
		tmpDir := t.TempDir()
		pidFile := tmpDir + "/nonexistent.pid"

		// Should not panic or error
		cleanupPIDFile(pidFile, discardLogger)
	})

	t.Run("cleanupPIDFile handles directory removal error gracefully", func(t *testing.T) {
		// Create a file in a protected directory (this is system-dependent)
		// Just verify it doesn't panic when it can't remove the file
		pidFile := "/this/should/not/exist/test.pid"

		// Should not panic
		cleanupPIDFile(pidFile, discardLogger)
	})
}

func TestServerCmd_AllowedOrigins(t *testing.T) {
	tests := []struct {
		name        string
		env         map[string]string
		args        []string
		expectedErr string
		expected    []string // only checked if expectedErr is empty
	}{
		// Environment variable scenarios (space-separated format)
		{
			name:     "env: single valid origin",
			env:      map[string]string{"AGENTAPI_ALLOWED_ORIGINS": "https://example.com"},
			args:     []string{},
			expected: []string{"https://example.com"},
		},
		{
			name:     "env: multiple valid origins space-separated",
			env:      map[string]string{"AGENTAPI_ALLOWED_ORIGINS": "https://example.com http://localhost:3000 https://app.example.com"},
			args:     []string{},
			expected: []string{"https://example.com", "http://localhost:3000", "https://app.example.com"},
		},
		{
			name:     "env: wildcard origin",
			env:      map[string]string{"AGENTAPI_ALLOWED_ORIGINS": "*"},
			args:     []string{},
			expected: []string{"*"},
		},
		{
			name:     "env: origin with tab",
			env:      map[string]string{"AGENTAPI_ALLOWED_ORIGINS": "https://example.com\thttp://localhost:3000"},
			args:     []string{},
			expected: []string{"https://example.com", "http://localhost:3000"},
		},

		// CLI flag scenarios (comma-separated format)
		{
			name:     "flag: single valid origin",
			args:     []string{"--allowed-origins", "https://example.com"},
			expected: []string{"https://example.com"},
		},
		{
			name:     "flag: multiple valid origins comma-separated",
			args:     []string{"--allowed-origins", "https://example.com,http://localhost:3000,https://app.example.com"},
			expected: []string{"https://example.com", "http://localhost:3000", "https://app.example.com"},
		},
		{
			name:     "flag: multiple valid origins with multiple flags",
			args:     []string{"--allowed-origins", "https://example.com", "--allowed-origins", "http://localhost:3000"},
			expected: []string{"https://example.com", "http://localhost:3000"},
		},
		{
			name:     "flag: wildcard origin",
			args:     []string{"--allowed-origins", "*"},
			expected: []string{"*"},
		},
		{
			name:     "flag: origin with newline",
			args:     []string{"--allowed-origins", "https://example.com\n"},
			expected: []string{"https://example.com"},
		},

		// Mixed scenarios (env + flag precedence)
		{
			name:     "mixed: flag overrides env",
			env:      map[string]string{"AGENTAPI_ALLOWED_ORIGINS": "https://env-example.com"},
			args:     []string{"--allowed-origins", "https://override.com"},
			expected: []string{"https://override.com"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			isolateViper(t)

			// Set environment variables if provided
			for key, value := range tt.env {
				t.Setenv(key, value)
			}

			serverCmd := CreateServerCmd()
			setupCommandOutput(t, serverCmd)
			serverCmd.SetArgs(append(tt.args, "--exit", "dummy-command"))
			err := serverCmd.Execute()

			if tt.expectedErr != "" {
				require.Error(t, err)
				assert.Contains(t, err.Error(), tt.expectedErr)
			} else {
				require.NoError(t, err)
				assert.Equal(t, tt.expected, viper.GetStringSlice(FlagAllowedOrigins))
			}
		})
	}
}

func TestServerCmd_MCPFileFlag(t *testing.T) {
	t.Run("mcp-file default is empty", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "", viper.GetString(FlagMCPFile))
	})

	t.Run("mcp-file can be set via CLI flag", func(t *testing.T) {
		isolateViper(t)

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--mcp-file", "/path/to/mcp.json", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/path/to/mcp.json", viper.GetString(FlagMCPFile))
	})

	t.Run("mcp-file can be set via environment variable", func(t *testing.T) {
		isolateViper(t)
		t.Setenv("AGENTAPI_MCP_FILE", "/env/path/to/mcp.json")

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/env/path/to/mcp.json", viper.GetString(FlagMCPFile))
	})

	t.Run("CLI flag overrides environment variable", func(t *testing.T) {
		isolateViper(t)
		t.Setenv("AGENTAPI_MCP_FILE", "/env/path/to/mcp.json")

		serverCmd := CreateServerCmd()
		setupCommandOutput(t, serverCmd)
		serverCmd.SetArgs([]string{"--mcp-file", "/cli/path/to/mcp.json", "--exit", "dummy-command"})
		err := serverCmd.Execute()
		require.NoError(t, err)

		assert.Equal(t, "/cli/path/to/mcp.json", viper.GetString(FlagMCPFile))
	})
}