Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

25.6 KB
Raw Blame
package config

import (
	"errors"
	"fmt"
	"strconv"
	"strings"

	"github.com/pinchtab/pinchtab/internal/browsers"
	"github.com/pinchtab/pinchtab/internal/safelog"
)

// SetConfigValue sets a dotted path in FileConfig (e.g., "server.port", "instanceDefaults.mode").
// The section vocabulary lives once, in configSections.
func SetConfigValue(fc *FileConfig, path string, value string) error {
	section, field, err := lookupConfigSection(path)
	if err != nil {
		return err
	}
	return section.set(fc, field, value)
}

func setServerField(s *ServerConfig, field, value string) error {
	switch field {
	case "port":
		s.Port = value
	case "bind":
		s.Bind = value
	case "token":
		s.Token = value
	case "stateDir":
		s.StateDir = value
	case "logLevel":
		if _, err := safelog.ParseLevel(value); err != nil {
			return fmt.Errorf("server.logLevel: %w", err)
		}
		s.LogLevel = strings.ToLower(strings.TrimSpace(value))
	case "networkBufferSize":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("server.networkBufferSize must be a number: %w", err)
		}
		s.NetworkBufferSize = &n
	case "retainNetworkBodies":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("server.retainNetworkBodies must be true or false: %w", err)
		}
		s.RetainNetworkBodies = &b
	case "retainNetworkBodyMaxBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("server.retainNetworkBodyMaxBytes must be a number: %w", err)
		}
		s.RetainNetworkBodyMaxBytes = &n
	case "trustProxyHeaders":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("server.trustProxyHeaders must be true or false: %w", err)
		}
		s.TrustProxyHeaders = &b
	case "cookieSecure":
		v := strings.ToLower(strings.TrimSpace(value))
		if v == "" || v == "auto" || v == "null" {
			// Unset to enable auto-detect behavior (tri-state: nil = auto-detect).
			s.CookieSecure = nil
			return nil
		}
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("server.cookieSecure must be true or false (or empty/auto/null to unset): %w", err)
		}
		s.CookieSecure = &b
	default:
		return fmt.Errorf("unknown field server.%s", field)
	}
	return nil
}

func setBrowserField(b *BrowserConfig, field, value string) error {
	if strings.HasPrefix(field, "cloak.") {
		return setCloakBrowserField(&b.Cloak, strings.TrimPrefix(field, "cloak."), value)
	}
	if strings.HasPrefix(field, "proxy.") {
		return setBrowserProxyField(&b.Proxy, strings.TrimPrefix(field, "proxy."), value)
	}
	if strings.HasPrefix(field, "targets.") {
		return setBrowserTargetField(&b.Targets, strings.TrimPrefix(field, "targets."), value)
	}
	switch field {
	case "provider":
		return fmt.Errorf("browser.provider is no longer supported; use browsers.default")
	case "version":
		b.BrowserVersion = value
	case "binary":
		b.BrowserBinary = value
	case "extraFlags":
		b.BrowserExtraFlags = value
	case "remoteDebuggingPort":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("browser.remoteDebuggingPort must be a number: %w", err)
		}
		b.BrowserDebugPort = &n
	case "extensionPaths":
		b.ExtensionPaths = parseCSVList(value)
	case "defaultTarget":
		b.DefaultTarget = value
	case "fallbackOrder":
		b.FallbackOrder = parseCSVList(value)
	default:
		return fmt.Errorf("unknown field browser.%s", field)
	}
	return nil
}

func setBrowsersField(b *BrowsersConfig, field, value string) error {
	switch field {
	case "default":
		id := strings.ToLower(strings.TrimSpace(value))
		if _, ok := browsers.Get(id); !ok {
			return fmt.Errorf("unknown browser %q (known: %v)", value, browsers.IDs())
		}
		b.Default = id
	case "available":
		b.Available = parseCSVList(value)
	default:
		return fmt.Errorf("unknown field browsers.%s", field)
	}
	return nil
}

func setBrowserProxyField(p *BrowserProxyConfig, field, value string) error {
	if strings.HasPrefix(field, "geo.") {
		if p.Geo == nil {
			p.Geo = &BrowserProxyGeoConfig{}
		}
		switch strings.TrimPrefix(field, "geo.") {
		case "timezone":
			p.Geo.Timezone = value
		case "locale":
			p.Geo.Locale = value
		case "webrtcIP":
			p.Geo.WebRTCIP = value
		case "countryISO":
			p.Geo.CountryISO = value
		default:
			return fmt.Errorf("unknown field proxy.%s", field)
		}
		return nil
	}
	switch field {
	case "server":
		p.Server = value
	case "bypassList":
		p.BypassList = parseCSVList(value)
	case "username":
		p.Username = value
	case "password":
		p.Password = value
	default:
		return fmt.Errorf("unknown field proxy.%s", field)
	}
	return nil
}

func setBrowserTargetField(targets *BrowserTargetsConfig, path, value string) error {
	name, field, ok := strings.Cut(path, ".")
	if !ok || name == "" || field == "" {
		return fmt.Errorf("invalid browser.targets path %q (expected targets.<name>.<field>)", path)
	}
	if !IsValidBrowserTargetName(name) {
		return fmt.Errorf("invalid browser target name %q (must match ^[a-z][a-z0-9-]{0,31}$)", name)
	}
	if *targets == nil {
		*targets = BrowserTargetsConfig{}
	}
	t := (*targets)[name]
	switch {
	case strings.HasPrefix(field, "cloak."):
		if err := setCloakBrowserField(&t.Cloak, strings.TrimPrefix(field, "cloak."), value); err != nil {
			return err
		}
	case strings.HasPrefix(field, "proxy."):
		if err := setBrowserProxyField(&t.Proxy, strings.TrimPrefix(field, "proxy."), value); err != nil {
			return err
		}
	case field == "provider":
		id := strings.ToLower(strings.TrimSpace(value))
		if _, ok := browsers.Get(id); !ok {
			return fmt.Errorf("unknown browser %q (known: %v)", value, browsers.IDs())
		}
		t.Provider = id
	case field == "binary":
		t.Binary = value
	case field == "extraFlags":
		t.ExtraFlags = value
	default:
		return fmt.Errorf("unknown field browser.targets.%s.%s", name, field)
	}
	(*targets)[name] = t
	return nil
}

func setCloakBrowserField(c *CloakBrowserConfig, field, value string) error {
	switch field {
	case "fingerprintSeed":
		c.FingerprintSeed = value
	case "platform":
		c.Platform = value
	case "locale":
		c.Locale = value
	case "timezone":
		c.Timezone = value
	case "webrtcIP":
		c.WebRTCIP = value
	case "fontsDir":
		c.FontsDir = value
	case "storageQuotaMB":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("browser.cloak.storageQuotaMB must be a number: %w", err)
		}
		c.StorageQuotaMB = &n
	case "disableDefaultStealthArgs":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("browser.cloak.disableDefaultStealthArgs must be true or false: %w", err)
		}
		c.DisableDefaultStealthArgs = &b
	default:
		return fmt.Errorf("unknown field browser.cloak.%s", field)
	}
	return nil
}

func setObservabilityField(o *ObservabilityFileConfig, field, value string) error {
	if strings.HasPrefix(field, "activity.") {
		return setActivityField(&o.Activity, strings.TrimPrefix(field, "activity."), value)
	}
	return fmt.Errorf("unknown field observability.%s", field)
}

func setActivityField(a *ActivityFileConfig, field, value string) error {
	if strings.HasPrefix(field, "events.") {
		return setActivityEventField(&a.Events, strings.TrimPrefix(field, "events."), value)
	}

	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("observability.activity.enabled: %w", err)
		}
		a.Enabled = &b
	case "sessionIdleSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("observability.activity.sessionIdleSec must be a number: %w", err)
		}
		a.SessionIdleSec = &n
	case "retentionDays":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("observability.activity.retentionDays must be a number: %w", err)
		}
		a.RetentionDays = &n
	case "stateDir":
		return errors.New(ActivityStateDirRefusal)
	default:
		return fmt.Errorf("unknown field observability.activity.%s", field)
	}
	return nil
}

func setActivityEventField(e *ActivityEventsFileConfig, field, value string) error {
	b, err := parseBool(value)
	if err != nil {
		return fmt.Errorf("observability.activity.events.%s: %w", field, err)
	}

	switch field {
	case "dashboard":
		e.Dashboard = &b
	case "server":
		e.Server = &b
	case "bridge":
		e.Bridge = &b
	case "orchestrator":
		e.Orchestrator = &b
	case "scheduler":
		e.Scheduler = &b
	case "mcp":
		e.MCP = &b
	case "other":
		e.Other = &b
	default:
		return fmt.Errorf("unknown field observability.activity.events.%s", field)
	}
	return nil
}

func setSessionsField(s *SessionsFileConfig, field, value string) error {
	if strings.HasPrefix(field, "dashboard.") {
		return setDashboardSessionField(&s.Dashboard, strings.TrimPrefix(field, "dashboard."), value)
	}
	if strings.HasPrefix(field, "agent.") {
		return setAgentSessionField(&s.Agent, strings.TrimPrefix(field, "agent."), value)
	}
	return fmt.Errorf("unknown field sessions.%s", field)
}

// setAgentSessionField is the write half of getAgentSessionField. mode is stored as given
// and left to ValidateFileConfig, which is where every other enumerated string in this
// editor is checked — a second vocabulary here would be a copy of the validator's.
func setAgentSessionField(s *AgentSessionFileConfig, field, value string) error {
	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("sessions.agent.enabled: %w", err)
		}
		s.Enabled = &b
	case "mode":
		s.Mode = value
	case "idleTimeoutSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("sessions.agent.idleTimeoutSec must be a number: %w", err)
		}
		s.IdleTimeoutSec = &n
	case "maxLifetimeSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("sessions.agent.maxLifetimeSec must be a number: %w", err)
		}
		s.MaxLifetimeSec = &n
	default:
		return fmt.Errorf("unknown field sessions.agent.%s", field)
	}
	return nil
}

func setDashboardSessionField(s *DashboardSessionFileConfig, field, value string) error {
	switch field {
	case "persist":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.persist: %w", err)
		}
		s.Persist = &b
	case "idleTimeoutSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.idleTimeoutSec must be a number: %w", err)
		}
		s.IdleTimeoutSec = &n
	case "maxLifetimeSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.maxLifetimeSec must be a number: %w", err)
		}
		s.MaxLifetimeSec = &n
	case "elevationWindowSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.elevationWindowSec must be a number: %w", err)
		}
		s.ElevationWindowSec = &n
	case "persistElevationAcrossRestart":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.persistElevationAcrossRestart: %w", err)
		}
		s.PersistElevationAcrossRestart = &b
	case "requireElevation":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("sessions.dashboard.requireElevation: %w", err)
		}
		s.RequireElevation = &b
	default:
		return fmt.Errorf("unknown field sessions.dashboard.%s", field)
	}
	return nil
}

func setInstanceDefaultsField(c *InstanceDefaultsConfig, field, value string) error {
	if strings.HasPrefix(field, "tabPolicy.") {
		if c.TabPolicy == nil {
			c.TabPolicy = &TabPolicyDefaults{}
		}
		return setTabPolicyField(c.TabPolicy, strings.TrimPrefix(field, "tabPolicy."), value)
	}
	switch field {
	case "mode":
		c.Mode = value
	case "noRestore":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.noRestore: %w", err)
		}
		c.NoRestore = &b
	case "timezone":
		c.Timezone = value
	case "blockImages":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.blockImages: %w", err)
		}
		c.BlockImages = &b
	case "blockMedia":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.blockMedia: %w", err)
		}
		c.BlockMedia = &b
	case "blockAds":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.blockAds: %w", err)
		}
		c.BlockAds = &b
	case "maxTabs":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.maxTabs must be a number: %w", err)
		}
		c.MaxTabs = &n
	case "maxParallelTabs":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.maxParallelTabs must be a number: %w", err)
		}
		c.MaxParallelTabs = &n
	case "userAgent":
		c.UserAgent = value
	case "noAnimations":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.noAnimations: %w", err)
		}
		c.NoAnimations = &b
	case "captureAllowActivation":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.captureAllowActivation: %w", err)
		}
		c.CaptureAllowActivation = &b
	case "humanize":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.humanize: %w", err)
		}
		c.Humanize = &b
	case "stealthLevel":
		c.StealthLevel = value
	case "tabEvictionPolicy":
		c.TabEvictionPolicy = value
	case "dialogAutoAccept":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.dialogAutoAccept: %w", err)
		}
		c.DialogAutoAccept = &b
	default:
		return fmt.Errorf("unknown field instanceDefaults.%s", field)
	}
	return nil
}

func setTabPolicyField(tp *TabPolicyDefaults, field, value string) error {
	switch field {
	case "eviction":
		tp.Eviction = value
	case "lifecycle":
		tp.Lifecycle = value
	case "closeDelaySec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.tabPolicy.closeDelaySec must be a number: %w", err)
		}
		tp.CloseDelaySec = &n
	case "restore":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("instanceDefaults.tabPolicy.restore: %w", err)
		}
		tp.Restore = &b
	default:
		return fmt.Errorf("unknown field instanceDefaults.tabPolicy.%s", field)
	}
	return nil
}

var securityBoolFields = map[string]func(*SecurityConfig) **bool{
	"allowEvaluate":         func(s *SecurityConfig) **bool { return &s.AllowEvaluate },
	"allowClipboard":        func(s *SecurityConfig) **bool { return &s.AllowClipboard },
	"allowMacro":            func(s *SecurityConfig) **bool { return &s.AllowMacro },
	"allowScreencast":       func(s *SecurityConfig) **bool { return &s.AllowScreencast },
	"allowDownload":         func(s *SecurityConfig) **bool { return &s.AllowDownload },
	"allowCookies":          func(s *SecurityConfig) **bool { return &s.AllowCookies },
	"allowStateExport":      func(s *SecurityConfig) **bool { return &s.AllowStateExport },
	"allowUpload":           func(s *SecurityConfig) **bool { return &s.AllowUpload },
	"allowNetworkIntercept": func(s *SecurityConfig) **bool { return &s.AllowNetworkIntercept },
	"allowMemory":           func(s *SecurityConfig) **bool { return &s.AllowMemory },
	"allowFileScheme":       func(s *SecurityConfig) **bool { return &s.AllowFileScheme },
	"trustLoopbackProxy":    func(s *SecurityConfig) **bool { return &s.TrustLoopbackProxy },
}

func setSecurityField(s *SecurityConfig, field, value string) error {
	if strings.HasPrefix(field, "attach.") {
		return setAttachField(&s.Attach, strings.TrimPrefix(field, "attach."), value)
	}
	if strings.HasPrefix(field, "idpi.") {
		return setIDPIField(s, strings.TrimPrefix(field, "idpi."), value)
	}
	if field == "allowedDomains" {
		domains := parseCSVList(value)
		if err := validateAllowlistEntries(domains); err != nil {
			return err
		}
		s.AllowedDomains = domains
		return nil
	}
	if field == "downloadAllowedDomains" {
		s.DownloadAllowedDomains = parseCSVList(value)
		return nil
	}
	if field == "trustedProxyCIDRs" {
		s.TrustedProxyCIDRs = parseCSVList(value)
		return nil
	}
	if field == "trustedResolveCIDRs" {
		s.TrustedResolveCIDRs = parseCSVList(value)
		return nil
	}
	switch field {
	case "downloadMaxBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.downloadMaxBytes must be a number: %w", err)
		}
		s.DownloadMaxBytes = &n
		return nil
	case "memorySnapshotMaxBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.memorySnapshotMaxBytes must be a number: %w", err)
		}
		s.MemorySnapshotMaxBytes = &n
		return nil
	case "uploadMaxRequestBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.uploadMaxRequestBytes must be a number: %w", err)
		}
		s.UploadMaxRequestBytes = &n
		return nil
	case "uploadMaxFiles":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.uploadMaxFiles must be a number: %w", err)
		}
		s.UploadMaxFiles = &n
		return nil
	case "uploadMaxFileBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.uploadMaxFileBytes must be a number: %w", err)
		}
		s.UploadMaxFileBytes = &n
		return nil
	case "uploadMaxTotalBytes":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.uploadMaxTotalBytes must be a number: %w", err)
		}
		s.UploadMaxTotalBytes = &n
		return nil
	case "maxRedirects":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.maxRedirects must be a number: %w", err)
		}
		s.MaxRedirects = &n
		return nil
	case "stateEncryptionKey":
		key := value
		s.StateEncryptionKey = &key
		return nil
	}

	slot, known := securityBoolFields[field]
	if !known {
		return fmt.Errorf("unknown field security.%s", field)
	}
	b, err := parseBool(value)
	if err != nil {
		return fmt.Errorf("security.%s: %w", field, err)
	}
	*slot(s) = &b
	return nil
}

func setProfilesField(p *ProfilesConfig, field, value string) error {
	switch field {
	case "baseDir":
		p.BaseDir = value
	case "defaultProfile":
		p.DefaultProfile = value
	case "quarantineKeep":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("profiles.quarantineKeep must be a number: %w", err)
		}
		if n < 0 {
			return fmt.Errorf("profiles.quarantineKeep must be >= 0 (0 keeps every quarantined profile)")
		}
		p.QuarantineKeep = &n
	default:
		return fmt.Errorf("unknown field profiles.%s", field)
	}
	return nil
}

func setMultiInstanceField(o *MultiInstanceConfig, field, value string) error {
	if strings.HasPrefix(field, "restart.") {
		return setMultiInstanceRestartField(&o.Restart, strings.TrimPrefix(field, "restart."), value)
	}

	switch field {
	case "strategy":
		o.Strategy = value
	case "allocationPolicy":
		o.AllocationPolicy = value
	case "instancePortStart":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("multiInstance.instancePortStart must be a number: %w", err)
		}
		o.InstancePortStart = &n
	case "instancePortEnd":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("multiInstance.instancePortEnd must be a number: %w", err)
		}
		o.InstancePortEnd = &n
	default:
		return fmt.Errorf("unknown field multiInstance.%s", field)
	}
	return nil
}

func setMultiInstanceRestartField(r *MultiInstanceRestartConfig, field, value string) error {
	n, err := strconv.Atoi(value)
	if err != nil {
		return fmt.Errorf("multiInstance.restart.%s must be a number: %w", field, err)
	}

	switch field {
	case "maxRestarts":
		r.MaxRestarts = &n
	case "initBackoffSec":
		r.InitBackoffSec = &n
	case "maxBackoffSec":
		r.MaxBackoffSec = &n
	case "stableAfterSec":
		r.StableAfterSec = &n
	default:
		return fmt.Errorf("unknown field multiInstance.restart.%s", field)
	}
	return nil
}

func setTimeoutsField(t *TimeoutsConfig, field, value string) error {
	n, err := strconv.Atoi(value)
	if err != nil {
		return fmt.Errorf("timeouts.%s must be a number: %w", field, err)
	}

	switch field {
	case "actionSec":
		t.ActionSec = n
	case "navigateSec":
		t.NavigateSec = n
	case "shutdownSec":
		t.ShutdownSec = n
	case "waitNavMs":
		t.WaitNavMs = n
	default:
		return fmt.Errorf("unknown field timeouts.%s", field)
	}
	return nil
}

func setAttachField(a *AttachConfig, field, value string) error {
	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.attach.enabled: %w", err)
		}
		a.Enabled = &b
	case "allowHosts":
		a.AllowHosts = parseCSVList(value)
	case "allowSchemes":
		a.AllowSchemes = parseCSVList(value)
	case "forwardProxyAuth":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.attach.forwardProxyAuth: %w", err)
		}
		a.ForwardProxyAuth = &b
	default:
		return fmt.Errorf("unknown field security.attach.%s", field)
	}
	return nil
}

func setIDPIField(s *SecurityConfig, field, value string) error {
	i := s.ensureIDPI()
	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.idpi.enabled: %w", err)
		}
		i.Enabled = b
	case "strictMode":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.idpi.strictMode: %w", err)
		}
		i.StrictMode = b
	case "scanContent":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.idpi.scanContent: %w", err)
		}
		i.ScanContent = b
	case "wrapContent":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("security.idpi.wrapContent: %w", err)
		}
		i.WrapContent = b
	case "customPatterns":
		i.CustomPatterns = parseCSVList(value)
	case "scanTimeoutSec":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.idpi.scanTimeoutSec must be a number: %w", err)
		}
		i.ScanTimeoutSec = n
	case "shieldThreshold":
		n, err := strconv.Atoi(value)
		if err != nil {
			return fmt.Errorf("security.idpi.shieldThreshold must be a number: %w", err)
		}
		if n < 0 || n > 100 {
			return fmt.Errorf("security.idpi.shieldThreshold must be between 0 and 100")
		}
		i.ShieldThreshold = n
	default:
		return fmt.Errorf("unknown field security.idpi.%s", field)
	}
	return nil
}

func setSchedulerField(s *SchedulerFileConfig, field, value string) error {
	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("scheduler.enabled: %w", err)
		}
		s.Enabled = &b
	case "strategy":
		s.Strategy = value
	case "maxQueueSize":
		return setIntPtrField(&s.MaxQueueSize, "scheduler.maxQueueSize", value)
	case "maxPerAgent":
		return setIntPtrField(&s.MaxPerAgent, "scheduler.maxPerAgent", value)
	case "maxInflight":
		return setIntPtrField(&s.MaxInflight, "scheduler.maxInflight", value)
	case "maxPerAgentInflight":
		return setIntPtrField(&s.MaxPerAgentFlight, "scheduler.maxPerAgentInflight", value)
	case "resultTTLSec":
		return setIntPtrField(&s.ResultTTLSec, "scheduler.resultTTLSec", value)
	case "workerCount":
		return setIntPtrField(&s.WorkerCount, "scheduler.workerCount", value)
	case "maxBatchSize":
		return setIntPtrField(&s.MaxBatchSize, "scheduler.maxBatchSize", value)
	default:
		return fmt.Errorf("unknown field scheduler.%s", field)
	}
	return nil
}

func setAutoSolverField(a *AutoSolverFileConfig, field, value string) error {
	if rest, ok := strings.CutPrefix(field, "external."); ok {
		return setAutoSolverExternalField(&a.External, rest, value)
	}
	if rest, ok := strings.CutPrefix(field, "credentials."); ok {
		return setAutoSolverCredentialsField(&a.Credentials, rest, value)
	}

	switch field {
	case "enabled":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("autoSolver.enabled: %w", err)
		}
		a.Enabled = &b
	case "autoTrigger":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("autoSolver.autoTrigger: %w", err)
		}
		a.AutoTrigger = &b
	case "triggerOnNavigate":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("autoSolver.triggerOnNavigate: %w", err)
		}
		a.TriggerOnNavigate = &b
	case "triggerOnAction":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("autoSolver.triggerOnAction: %w", err)
		}
		a.TriggerOnAction = &b
	case "llmFallback":
		b, err := parseBool(value)
		if err != nil {
			return fmt.Errorf("autoSolver.llmFallback: %w", err)
		}
		a.LLMFallback = &b
	case "maxAttempts":
		return setIntPtrField(&a.MaxAttempts, "autoSolver.maxAttempts", value)
	case "solverTimeoutSec":
		return setIntPtrField(&a.SolverTimeoutSec, "autoSolver.solverTimeoutSec", value)
	case "retryBaseDelayMs":
		return setIntPtrField(&a.RetryBaseDelayMs, "autoSolver.retryBaseDelayMs", value)
	case "retryMaxDelayMs":
		return setIntPtrField(&a.RetryMaxDelayMs, "autoSolver.retryMaxDelayMs", value)
	case "llmProvider":
		a.LLMProvider = value
	case "solvers":
		a.Solvers = parseCSVList(value)
	default:
		return fmt.Errorf("unknown field autoSolver.%s", field)
	}
	return nil
}

func setAutoSolverExternalField(e *AutoSolverExtConf, field, value string) error {
	switch field {
	case "capsolverKey":
		e.CapsolverKey = value
	case "twoCaptchaKey":
		e.TwoCaptchaKey = value
	default:
		return fmt.Errorf("unknown field autoSolver.external.%s", field)
	}
	return nil
}

func setAutoSolverCredentialsField(c *AutoSolverCredentialsConf, field, value string) error {
	switch {
	case strings.HasPrefix(field, "login."):
		switch strings.TrimPrefix(field, "login.") {
		case "user":
			c.Login.User = value
		case "password":
			c.Login.Password = value
		default:
			return fmt.Errorf("unknown field autoSolver.credentials.%s", field)
		}
	case strings.HasPrefix(field, "signup."):
		switch strings.TrimPrefix(field, "signup.") {
		case "name":
			c.Signup.Name = value
		case "email":
			c.Signup.Email = value
		case "password":
			c.Signup.Password = value
		default:
			return fmt.Errorf("unknown field autoSolver.credentials.%s", field)
		}
	case strings.HasPrefix(field, "form."):
		switch strings.TrimPrefix(field, "form.") {
		case "field1":
			c.Form.Field1 = value
		case "field2":
			c.Form.Field2 = value
		case "email":
			c.Form.Email = value
		default:
			return fmt.Errorf("unknown field autoSolver.credentials.%s", field)
		}
	default:
		return fmt.Errorf("unknown field autoSolver.credentials.%s", field)
	}
	return nil
}

// setIntPtrField parses value into an int and points field at it, naming the full path
// in the refusal — the same shape every numeric setter in this package uses.
func setIntPtrField(field **int, path, value string) error {
	n, err := strconv.Atoi(value)
	if err != nil {
		return fmt.Errorf("%s must be a number: %w", path, err)
	}
	*field = &n
	return nil
}