LaodingBot/internal/config/config.go

package config

import (
	"bufio"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
)

type Config struct {
	MessageChannel          string
	LogLevel                string
	SoulPath                string
	SkillsDir               string
	ReactMaxSteps           int
	ToolCallTimeoutSec      int
	ToolOutputMaxChars      int
	EnableCapabilityGap     bool
	AutoSkillDir            string
	GapDraftTriggerCount    int
	GapClusterLookbackHours int

	Telegram  TelegramConfig
	Feishu    FeishuConfig
	WebUI     WebUIConfig
	LLM       LLMConfig
	Security  SecurityConfig
	WebSearch WebSearchConfig

	SQLitePath string
}

type TelegramConfig struct {
	Token              string
	PollTimeoutSeconds int
}

type FeishuConfig struct {
	AppID       string
	AppSecret   string
	VerifyToken string
	ListenAddr  string
	EventPath   string
}

type WebUIConfig struct {
	ListenAddr     string
	MaxUploadBytes int64
}

type LLMConfig struct {
	BaseURL        string
	APIKey         string
	Model          string
	FileModel      string
	FilePromptMode string
}

type SecurityConfig struct {
	AllowedDirs     []string
	AllowedCommands []string
	WorkDir         string
}

type WebSearchConfig struct {
	Engine string // "duckduckgo" or "brave"
	APIKey string
}

func Load() (Config, error) {
	agentWorkspaceDir := resolveAgentWorkspaceDir()
	if err := preloadEnvFiles(); err != nil {
		return Config{}, err
	}
	defaultWorkSubdir := filepath.Join(agentWorkspaceDir, "workspace")
	defaultDataDir := filepath.Join(agentWorkspaceDir, "data")

	cfg := Config{
		MessageChannel:          defaultIfEmpty(os.Getenv("MESSAGE_CHANNEL"), "telegram"),
		LogLevel:                defaultIfEmpty(os.Getenv("LOG_LEVEL"), "info"),
		SoulPath:                defaultIfEmpty(os.Getenv("SOUL_PATH"), filepath.Join(agentWorkspaceDir, "bot_context", "soul.md")),
		SkillsDir:               defaultIfEmpty(os.Getenv("SKILLS_DIR"), filepath.Join(agentWorkspaceDir, "skills")),
		ReactMaxSteps:           intFromEnv("REACT_MAX_STEPS", 0),
		ToolCallTimeoutSec:      intFromEnv("TOOL_CALL_TIMEOUT_SEC", 15),
		ToolOutputMaxChars:      intFromEnv("TOOL_OUTPUT_MAX_CHARS", 4000),
		EnableCapabilityGap:     boolFromEnv("ENABLE_CAPABILITY_GAP", true),
		AutoSkillDir:            defaultIfEmpty(os.Getenv("AUTO_SKILL_DIR"), filepath.Join(agentWorkspaceDir, "skills")),
		GapDraftTriggerCount:    intFromEnv("GAP_DRAFT_TRIGGER_COUNT", 3),
		GapClusterLookbackHours: intFromEnv("GAP_CLUSTER_LOOKBACK_HOURS", 168),
		Telegram: TelegramConfig{
			Token:              strings.TrimSpace(os.Getenv("TELEGRAM_BOT_TOKEN")),
			PollTimeoutSeconds: intFromEnv("TELEGRAM_POLL_TIMEOUT_SECONDS", 30),
		},
		Feishu: FeishuConfig{
			AppID:       strings.TrimSpace(os.Getenv("FEISHU_APP_ID")),
			AppSecret:   strings.TrimSpace(os.Getenv("FEISHU_APP_SECRET")),
			VerifyToken: strings.TrimSpace(os.Getenv("FEISHU_VERIFY_TOKEN")),
			ListenAddr:  defaultIfEmpty(os.Getenv("FEISHU_LISTEN_ADDR"), ":8080"),
			EventPath:   defaultIfEmpty(os.Getenv("FEISHU_EVENT_PATH"), "/feishu/events"),
		},
		WebUI: WebUIConfig{
			ListenAddr:     defaultIfEmpty(os.Getenv("WEBUI_LISTEN_ADDR"), ":8090"),
			MaxUploadBytes: int64(intFromEnv("WEBUI_MAX_UPLOAD_MB", 20)) * 1024 * 1024,
		},
		LLM: LLMConfig{
			BaseURL:        strings.TrimRight(defaultIfEmpty(os.Getenv("LLM_BASE_URL"), "https://api.openai.com/v1"), "/"),
			APIKey:         strings.TrimSpace(os.Getenv("LLM_API_KEY")),
			Model:          defaultIfEmpty(os.Getenv("LLM_MODEL"), "gpt-4o-mini"),
			FileModel:      defaultIfEmpty(os.Getenv("LLM_FILE_MODEL"), defaultIfEmpty(os.Getenv("LLM_MODEL"), "gpt-4o-mini")),
			FilePromptMode: normalizeFilePromptMode(defaultIfEmpty(os.Getenv("LLM_FILE_PROMPT_MODE"), "user_content_file_parts")),
		},
		SQLitePath: defaultIfEmpty(os.Getenv("SQLITE_PATH"), filepath.Join(defaultDataDir, "laodingbot.db")),
		WebSearch: WebSearchConfig{
			Engine: defaultIfEmpty(os.Getenv("WEB_SEARCH_ENGINE"), "duckduckgo"),
			APIKey: strings.TrimSpace(os.Getenv("WEB_SEARCH_API_KEY")),
		},
		Security: SecurityConfig{
			AllowedDirs:     splitCSV(defaultIfEmpty(os.Getenv("ALLOWED_DIRS"), strings.Join([]string{agentWorkspaceDir, defaultDataDir, defaultWorkSubdir}, ","))),
			AllowedCommands: splitCSV(defaultIfEmpty(os.Getenv("ALLOWED_COMMANDS"), "pwd,ls,cat,echo,grep,find,head,tail,go")),
			WorkDir:         defaultIfEmpty(os.Getenv("WORK_DIR"), defaultWorkSubdir),
		},
	}

	cfg.MessageChannel = strings.ToLower(strings.TrimSpace(cfg.MessageChannel))
	cfg.LogLevel = strings.ToLower(strings.TrimSpace(cfg.LogLevel))
	if cfg.MessageChannel != "telegram" && cfg.MessageChannel != "feishu" && cfg.MessageChannel != "webui" {
		return Config{}, fmt.Errorf("MESSAGE_CHANNEL must be telegram, feishu, or webui")
	}
	if cfg.LogLevel != "debug" && cfg.LogLevel != "info" && cfg.LogLevel != "warn" && cfg.LogLevel != "error" {
		return Config{}, fmt.Errorf("LOG_LEVEL must be debug, info, warn, or error")
	}
	if cfg.ReactMaxSteps < 1 || cfg.ReactMaxSteps > 8 {
		return Config{}, fmt.Errorf("REACT_MAX_STEPS must be between 1 and 8")
	}
	if cfg.ToolCallTimeoutSec < 1 || cfg.ToolCallTimeoutSec > 300 {
		return Config{}, fmt.Errorf("TOOL_CALL_TIMEOUT_SEC must be between 1 and 300")
	}
	if cfg.ToolOutputMaxChars < 256 || cfg.ToolOutputMaxChars > 200000 {
		return Config{}, fmt.Errorf("TOOL_OUTPUT_MAX_CHARS must be between 256 and 200000")
	}
	if cfg.GapDraftTriggerCount < 1 || cfg.GapDraftTriggerCount > 100 {
		return Config{}, fmt.Errorf("GAP_DRAFT_TRIGGER_COUNT must be between 1 and 100")
	}
	if cfg.GapClusterLookbackHours < 1 || cfg.GapClusterLookbackHours > 24*365 {
		return Config{}, fmt.Errorf("GAP_CLUSTER_LOOKBACK_HOURS must be between 1 and 8760")
	}
	if cfg.WebUI.MaxUploadBytes < 1024 || cfg.WebUI.MaxUploadBytes > 200*1024*1024 {
		return Config{}, fmt.Errorf("WEBUI_MAX_UPLOAD_MB must be between 1 and 200")
	}

	if cfg.MessageChannel == "telegram" {
		if cfg.Telegram.Token == "" {
			return Config{}, fmt.Errorf("TELEGRAM_BOT_TOKEN is required when MESSAGE_CHANNEL=telegram")
		}
		if cfg.Feishu.AppID != "" || cfg.Feishu.AppSecret != "" {
			return Config{}, fmt.Errorf("feishu config must be empty when MESSAGE_CHANNEL=telegram")
		}
	}

	if cfg.MessageChannel == "feishu" {
		if cfg.Feishu.AppID == "" || cfg.Feishu.AppSecret == "" {
			return Config{}, fmt.Errorf("FEISHU_APP_ID and FEISHU_APP_SECRET are required when MESSAGE_CHANNEL=feishu")
		}
		if cfg.Telegram.Token != "" {
			return Config{}, fmt.Errorf("TELEGRAM_BOT_TOKEN must be empty when MESSAGE_CHANNEL=feishu")
		}
	}

	if cfg.MessageChannel == "webui" {
		if strings.TrimSpace(cfg.WebUI.ListenAddr) == "" {
			return Config{}, fmt.Errorf("WEBUI_LISTEN_ADDR is required when MESSAGE_CHANNEL=webui")
		}
	}

	if cfg.LLM.APIKey == "" {
		return Config{}, fmt.Errorf("LLM_API_KEY is required")
	}
	if cfg.LLM.FilePromptMode != "user_content_file_parts" && cfg.LLM.FilePromptMode != "system_fileid_uri" {
		return Config{}, fmt.Errorf("LLM_FILE_PROMPT_MODE must be one of: user_content_file_parts, system_fileid_uri")
	}

	cfg.SoulPath = resolvePathInWorkspace(cfg.SoulPath, agentWorkspaceDir)
	cfg.SkillsDir = resolvePathInWorkspace(cfg.SkillsDir, agentWorkspaceDir)
	cfg.AutoSkillDir = resolvePathInWorkspace(cfg.AutoSkillDir, agentWorkspaceDir)
	cfg.SQLitePath = resolvePathInWorkspace(cfg.SQLitePath, agentWorkspaceDir)
	cfg.Security.WorkDir = resolvePathInWorkspace(cfg.Security.WorkDir, agentWorkspaceDir)
	cfg.Security.AllowedDirs = resolveDirsInWorkspace(cfg.Security.AllowedDirs, agentWorkspaceDir)
	cfg.Security.AllowedDirs = ensureAllowedDirs(cfg.Security.AllowedDirs,
		filepath.Clean(agentWorkspaceDir),
		filepath.Join(agentWorkspaceDir, "skills"),
		filepath.Join(agentWorkspaceDir, "data"),
		filepath.Join(agentWorkspaceDir, "workspace"),
	)
	cfg.Security.AllowedCommands = ensureAllowedCommands(cfg.Security.AllowedCommands, "go", "curl", "curl.exe")

	return cfg, nil
}

func preloadEnvFiles() error {
	explicit := strings.TrimSpace(os.Getenv("CONFIG_ENV_FILE"))
	if explicit != "" {
		if err := tryLoadEnvFile(explicit, true); err != nil {
			return fmt.Errorf("load env file %s failed: %w", explicit, err)
		}
	}

	workspaceDir := resolveAgentWorkspaceDir()
	workspaceEnv := filepath.Join(workspaceDir, "configs", "env")
	workspaceDotEnv := filepath.Join(workspaceDir, ".env")
	if err := tryLoadEnvFile(workspaceEnv, true); err != nil {
		return fmt.Errorf("load env file %s failed: %w", workspaceEnv, err)
	}
	if err := tryLoadEnvFile(workspaceDotEnv, true); err != nil {
		return fmt.Errorf("load env file %s failed: %w", workspaceDotEnv, err)
	}

	if err := tryLoadEnvFile("configs/env", false); err != nil {
		return fmt.Errorf("load env file %s failed: %w", "configs/env", err)
	}
	if err := tryLoadEnvFile(".env", false); err != nil {
		return fmt.Errorf("load env file %s failed: %w", ".env", err)
	}
	return nil
}

func tryLoadEnvFile(path string, override bool) error {
	err := loadEnvFile(path, override)
	if err != nil && errors.Is(err, os.ErrNotExist) {
		return nil
	}
	return err
}

func resolveAgentWorkspaceDir() string {
	raw := strings.TrimSpace(os.Getenv("AGENT_WORKSPACE_DIR"))
	if raw == "" {
		raw = filepath.Join(".", "workspace", "agent_runtime")
	}
	abs, err := filepath.Abs(raw)
	if err != nil {
		return raw
	}
	return abs
}

func resolvePathInWorkspace(path, workspaceDir string) string {
	path = strings.TrimSpace(path)
	if path == "" {
		return path
	}
	if filepath.IsAbs(path) {
		return filepath.Clean(path)
	}
	return filepath.Clean(filepath.Join(workspaceDir, path))
}

func resolveDirsInWorkspace(dirs []string, workspaceDir string) []string {
	out := make([]string, 0, len(dirs))
	for _, d := range dirs {
		resolved := resolvePathInWorkspace(d, workspaceDir)
		if strings.TrimSpace(resolved) != "" {
			out = append(out, resolved)
		}
	}
	if len(out) == 0 {
		out = append(out, filepath.Clean(workspaceDir))
	}
	return out
}

func ensureAllowedDirs(existing []string, dirs ...string) []string {
	set := map[string]struct{}{}
	out := make([]string, 0, len(existing)+len(dirs))
	for _, d := range existing {
		clean := filepath.Clean(strings.TrimSpace(d))
		if clean == "" {
			continue
		}
		if _, ok := set[clean]; ok {
			continue
		}
		set[clean] = struct{}{}
		out = append(out, clean)
	}
	for _, d := range dirs {
		clean := filepath.Clean(strings.TrimSpace(d))
		if clean == "" {
			continue
		}
		if _, ok := set[clean]; ok {
			continue
		}
		set[clean] = struct{}{}
		out = append(out, clean)
	}
	return out
}

func ensureAllowedCommands(existing []string, commands ...string) []string {
	set := map[string]struct{}{}
	out := make([]string, 0, len(existing)+len(commands))
	for _, c := range existing {
		cmd := strings.ToLower(strings.TrimSpace(c))
		if cmd == "" {
			continue
		}
		if _, ok := set[cmd]; ok {
			continue
		}
		set[cmd] = struct{}{}
		out = append(out, cmd)
	}
	for _, c := range commands {
		cmd := strings.ToLower(strings.TrimSpace(c))
		if cmd == "" {
			continue
		}
		if _, ok := set[cmd]; ok {
			continue
		}
		set[cmd] = struct{}{}
		out = append(out, cmd)
	}
	return out
}

func loadEnvFile(path string, override bool) error {
	absPath, err := filepath.Abs(path)
	if err != nil {
		absPath = path
	}

	f, err := os.Open(absPath)
	if err != nil {
		return err
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		line = strings.TrimPrefix(line, "export ")
		idx := strings.Index(line, "=")
		if idx <= 0 {
			continue
		}
		key := strings.TrimSpace(line[:idx])
		if key == "" {
			continue
		}
		val := strings.TrimSpace(line[idx+1:])
		if len(val) >= 2 {
			if (val[0] == '"' && val[len(val)-1] == '"') || (val[0] == '\'' && val[len(val)-1] == '\'') {
				val = val[1 : len(val)-1]
			}
		}
		if !override {
			if _, exists := os.LookupEnv(key); exists {
				continue
			}
		}
		if err := os.Setenv(key, val); err != nil {
			return err
		}
	}
	return scanner.Err()
}

func defaultIfEmpty(v, d string) string {
	v = strings.TrimSpace(v)
	if v == "" {
		return d
	}
	return v
}

func intFromEnv(name string, d int) int {
	raw := strings.TrimSpace(os.Getenv(name))
	if raw == "" {
		return d
	}
	v, err := strconv.Atoi(raw)
	if err != nil {
		return d
	}
	return v
}

func boolFromEnv(name string, d bool) bool {
	raw := strings.ToLower(strings.TrimSpace(os.Getenv(name)))
	if raw == "" {
		return d
	}
	if raw == "1" || raw == "true" || raw == "yes" || raw == "on" {
		return true
	}
	if raw == "0" || raw == "false" || raw == "no" || raw == "off" {
		return false
	}
	return d
}

func splitCSV(raw string) []string {
	parts := strings.Split(raw, ",")
	out := make([]string, 0, len(parts))
	for _, p := range parts {
		v := strings.TrimSpace(p)
		if v != "" {
			out = append(out, v)
		}
	}
	return out
}

func normalizeFilePromptMode(v string) string {
	v = strings.ToLower(strings.TrimSpace(v))
	if v == "" {
		return "user_content_file_parts"
	}
	if v == "system_fileid" || v == "system_fileid_url" || v == "system_fileid_uri" {
		return "system_fileid_uri"
	}
	return v
}