High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
fix: pin legacy-vs-targets config precedence and align conflict warning
Boschafb29af51e59
diff --git a/internal/config/browser_proxy.go b/internal/config/browser_proxy.goindex ef4a809b..106a50f5 100644--- a/internal/config/browser_proxy.go+++ b/internal/config/browser_proxy.go@@ -97,12 +97,14 @@ func ParseProxyServer(server string) (scheme, host string, port int, err error)if rest == "" {return "", "", 0, fmt.Errorf("proxy server %q is missing host:port", server)}- if strings.ContainsRune(rest, '@') {- return "", "", 0, fmt.Errorf("proxy server %q must not include embedded credentials; use the username/password fields", server)- }+ // Strip any path before the credential check: an '@' in the path+ // (http://host:8080/p@th) is not embedded userinfo.if slash := strings.Index(rest, "/"); slash >= 0 {rest = rest[:slash]}+ if strings.ContainsRune(rest, '@') {+ return "", "", 0, fmt.Errorf("proxy server %q must not include embedded credentials; use the username/password fields", server)+ }h, p, splitErr := net.SplitHostPort(rest)if splitErr != nil {return "", "", 0, fmt.Errorf("proxy server %q must be of the form scheme://host:port: %w", server, splitErr)@@ -179,14 +181,16 @@ func ValidateBrowserProxy(field string, p BrowserProxyConfig) []error {}// BrowserProxyFlags returns credential-free --proxy-server/--proxy-bypass-list flags; auth is delivered via CDP.-func BrowserProxyFlags(p BrowserProxyConfig) []string {+// A malformed server is a hard error: launching without the configured proxy+// would silently egress traffic from the real IP — the worst failure mode for+// users who configured a proxy for anonymity.+func BrowserProxyFlags(p BrowserProxyConfig) ([]string, error) {if p.IsZero() {- return nil+ return nil, nil}scheme, host, port, err := ParseProxyServer(p.Server)if err != nil {- // Caller should have validated; fail open rather than crash the launch.- return nil+ return nil, fmt.Errorf("browser.proxy.server is invalid; refusing to launch without the configured proxy (traffic would egress directly): %w", err)}authority := net.JoinHostPort(host, strconv.Itoa(port))flags := []string{@@ -195,7 +199,7 @@ func BrowserProxyFlags(p BrowserProxyConfig) []string {if bypass := joinBypassList(p.BypassList); bypass != "" {flags = append(flags, "--proxy-bypass-list="+bypass)}- return flags+ return flags, nil}func joinBypassList(items []string) string {diff --git a/internal/config/browser_proxy_test.go b/internal/config/browser_proxy_test.goindex 5614475d..62690c38 100644--- a/internal/config/browser_proxy_test.go+++ b/internal/config/browser_proxy_test.go@@ -226,14 +226,20 @@ func TestBrowserProxyRedacted(t *testing.T) {func TestBrowserProxyFlags(t *testing.T) {t.Run("disabled proxy emits no flags", func(t *testing.T) {- flags := BrowserProxyFlags(BrowserProxyConfig{})+ flags, err := BrowserProxyFlags(BrowserProxyConfig{})+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }if len(flags) != 0 {t.Fatalf("expected no flags, got %v", flags)}})t.Run("server only", func(t *testing.T) {- flags := BrowserProxyFlags(BrowserProxyConfig{Server: "http://proxy.example.com:8080"})+ flags, err := BrowserProxyFlags(BrowserProxyConfig{Server: "http://proxy.example.com:8080"})+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }if len(flags) != 1 {t.Fatalf("expected 1 flag, got %v", flags)}@@ -244,10 +250,13 @@ func TestBrowserProxyFlags(t *testing.T) {})t.Run("with bypass list", func(t *testing.T) {- flags := BrowserProxyFlags(BrowserProxyConfig{+ flags, err := BrowserProxyFlags(BrowserProxyConfig{Server: "socks5://10.0.0.1:1080",BypassList: []string{"*.local", "127.0.0.1"},})+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }if len(flags) != 2 {t.Fatalf("expected 2 flags, got %v", flags)}@@ -260,7 +269,10 @@ func TestBrowserProxyFlags(t *testing.T) {})t.Run("ipv6 host stays bracketed", func(t *testing.T) {- flags := BrowserProxyFlags(BrowserProxyConfig{Server: "http://[2001:db8::1]:8080"})+ flags, err := BrowserProxyFlags(BrowserProxyConfig{Server: "http://[2001:db8::1]:8080"})+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }if len(flags) != 1 {t.Fatalf("expected 1 flag, got %v", flags)}@@ -270,17 +282,35 @@ func TestBrowserProxyFlags(t *testing.T) {})t.Run("credentials never leak into flag", func(t *testing.T) {- flags := BrowserProxyFlags(BrowserProxyConfig{+ flags, err := BrowserProxyFlags(BrowserProxyConfig{Server: "http://proxy.example.com:8080",Username: "alice",Password: "s3cr3t",})+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }for _, f := range flags {if strings.Contains(f, "alice") || strings.Contains(f, "s3cr3t") {t.Errorf("credential leaked into Chrome flag: %q", f)}}})++ // M2 regression: a malformed server must fail closed — launching without+ // the configured proxy would egress traffic from the real IP.+ t.Run("malformed server fails closed", func(t *testing.T) {+ flags, err := BrowserProxyFlags(BrowserProxyConfig{Server: "not a proxy url"})+ if err == nil {+ t.Fatalf("expected error for malformed server, got flags %v", flags)+ }+ if !strings.Contains(err.Error(), "refusing to launch") {+ t.Fatalf("error should name the fail-closed consequence: %v", err)+ }+ if len(flags) != 0 {+ t.Fatalf("no flags expected on error, got %v", flags)+ }+ })}func TestMigrateLegacyBrowserConfig_ProxyCarriesIntoSynthesizedTarget(t *testing.T) {@@ -482,3 +512,17 @@ func TestFileConfig_ProxyRoundTrip(t *testing.T) {}})}++// L7(a): an '@' in the URL path is not embedded userinfo.+func TestParseProxyServer_PathWithAtSignAccepted(t *testing.T) {+ scheme, host, port, err := ParseProxyServer("http://proxy.example:8080/p@th")+ if err != nil {+ t.Fatalf("path containing '@' should parse: %v", err)+ }+ if scheme != "http" || host != "proxy.example" || port != 8080 {+ t.Fatalf("parsed %s://%s:%d, want http://proxy.example:8080", scheme, host, port)+ }+ if _, _, _, err := ParseProxyServer("http://user:[email protected]:8080"); err == nil {+ t.Fatal("embedded credentials must still be rejected")+ }+}diff --git a/internal/config/browser_targets_test.go b/internal/config/browser_targets_test.goindex fe2eae55..bb696335 100644--- a/internal/config/browser_targets_test.go+++ b/internal/config/browser_targets_test.go@@ -1102,3 +1102,98 @@ func TestApplyTargetOverride_ClonesTargetProxyAndTargetsMap(t *testing.T) {t.Fatalf("target map shared with override: %+v", original)}}++// --- Round-trip preservation of user-authored targets (H3 regression) ---++func TestApplyFileConfig_ExplicitDefaultTargetDrivesDefaultBrowser(t *testing.T) {+ fc := &FileConfig{+ Browser: BrowserConfig{+ Targets: BrowserTargetsConfig{+ DefaultBrowserTargetName: {+ Provider: BrowserCloak,+ Binary: "/opt/cloak/bin",+ Proxy: BrowserProxyConfig{+ Server: "http://proxy.example:8080",+ Username: "user",+ Password: "secret",+ },+ },+ },+ },+ }+ cfg := &RuntimeConfig{}+ applyFileConfig(cfg, fc)++ if cfg.DefaultBrowser != BrowserCloak {+ t.Fatalf("DefaultBrowser = %q, want %q (derived from explicit default target)", cfg.DefaultBrowser, BrowserCloak)+ }+ if cfg.TargetsSynthesized {+ t.Fatal("user-authored targets must not be marked synthesized")+ }++ out := FileConfigFromRuntime(cfg)+ got, ok := out.Browser.Targets[DefaultBrowserTargetName]+ if !ok {+ t.Fatalf("default target lost in round-trip: %+v", out.Browser.Targets)+ }+ if got.Provider != BrowserCloak {+ t.Fatalf("Provider = %q, want %q (user target must survive round-trip)", got.Provider, BrowserCloak)+ }+ if got.Binary != "/opt/cloak/bin" {+ t.Fatalf("Binary = %q, want /opt/cloak/bin", got.Binary)+ }+ if got.Proxy.Password != "secret" {+ t.Fatalf("proxy credentials wiped in round-trip: %+v", got.Proxy)+ }+}++func TestFileConfigFromRuntime_UserTargetSurvivesContradictoryDefaultBrowser(t *testing.T) {+ fc := &FileConfig{+ Browsers: BrowsersConfig{Default: BrowserChrome},+ Browser: BrowserConfig{+ Targets: BrowserTargetsConfig{+ DefaultBrowserTargetName: {+ Provider: BrowserCloak,+ Binary: "/opt/cloak/bin",+ Proxy: BrowserProxyConfig{Server: "http://proxy.example:8080", Username: "u", Password: "secret"},+ },+ },+ },+ }+ cfg := &RuntimeConfig{}+ applyFileConfig(cfg, fc)++ if cfg.DefaultBrowser != BrowserChrome {+ t.Fatalf("DefaultBrowser = %q, want explicit browsers.default to win", cfg.DefaultBrowser)+ }++ out := FileConfigFromRuntime(cfg)+ got := out.Browser.Targets[DefaultBrowserTargetName]+ if got.Provider != BrowserCloak || got.Binary != "/opt/cloak/bin" || got.Proxy.Password != "secret" {+ t.Fatalf("user-authored target rewritten despite contradictory browsers.default: %+v", got)+ }+}++func TestFileConfigFromRuntime_SynthesizedTargetStillReconciles(t *testing.T) {+ fc := &FileConfig{+ Browser: BrowserConfig{BrowserBinary: "/usr/bin/chrome"},+ }+ cfg := &RuntimeConfig{}+ applyFileConfig(cfg, fc)++ if !cfg.TargetsSynthesized {+ t.Fatal("legacy-only config should synthesize targets")+ }+ if cfg.DefaultBrowser != BrowserChrome {+ t.Fatalf("DefaultBrowser = %q, want chrome", cfg.DefaultBrowser)+ }++ // Orchestrator child-launch scenario: caller overrides the provider+ // without rewriting Targets; the synthesized target must follow.+ cfg.DefaultBrowser = BrowserCloak+ out := FileConfigFromRuntime(cfg)+ got := out.Browser.Targets[DefaultBrowserTargetName]+ if got.Provider != BrowserCloak {+ t.Fatalf("synthesized target Provider = %q, want reconciled to %q", got.Provider, BrowserCloak)+ }+}diff --git a/internal/config/browsers_config_test.go b/internal/config/browsers_config_test.goindex e0d12a22..22b84484 100644--- a/internal/config/browsers_config_test.go+++ b/internal/config/browsers_config_test.go@@ -29,9 +29,6 @@ func TestValidateBrowsersBlock_ValidConfig(t *testing.T) {Browsers: BrowsersConfig{Default: "chrome",Available: []string{"chrome", "cloak"},- Config: map[string]BrowserItemConfig{- "cloak": {Binary: "/opt/cloak/chrome"},- },},}errs := ValidateFileConfig(fc)@@ -100,24 +97,35 @@ func TestValidateBrowsersBlock_DefaultNotInAvailable(t *testing.T) {}}-func TestValidateBrowsersBlock_UnknownConfigKey(t *testing.T) {- fc := &FileConfig{- Browsers: BrowsersConfig{- Config: map[string]BrowserItemConfig{- "edge": {Binary: "/usr/bin/edge"},- },- },- }- errs := ValidateFileConfig(fc)- found := false- for _, e := range errs {- if strings.Contains(e.Error(), "browsers.config") && strings.Contains(e.Error(), "edge") {- found = true- break- }- }- if !found {- t.Fatalf("expected browsers.config error for unknown browser key, got: %v", errs)+// browsers.config was never applied anywhere; any presence — known or unknown+// browser keys, empty or populated items — is rejected with targets guidance.+func TestValidateBrowsersBlock_ConfigBlockRejected(t *testing.T) {+ cases := []struct {+ name string+ config map[string]BrowserItemConfig+ }{+ {"known browser key", map[string]BrowserItemConfig{"cloak": {Binary: "/opt/cloak/chrome"}}},+ {"unknown browser key", map[string]BrowserItemConfig{"edge": {Binary: "/usr/bin/edge"}}},+ {"empty item", map[string]BrowserItemConfig{"ghost-chrome": {}}},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ fc := &FileConfig{+ Browsers: BrowsersConfig{Config: tc.config},+ }+ errs := ValidateFileConfig(fc)+ found := false+ for _, e := range errs {+ if strings.Contains(e.Error(), "browsers.config is no longer supported") &&+ strings.Contains(e.Error(), "browser.targets") {+ found = true+ break+ }+ }+ if !found {+ t.Fatalf("expected browsers.config not-supported error, got: %v", errs)+ }+ })}}@@ -141,10 +149,6 @@ func TestValidateBrowsersBlock_AllPhase1Browsers(t *testing.T) {Browsers: BrowsersConfig{Default: "chrome",Available: []string{"chrome", "ghost-chrome", "cloak"},- Config: map[string]BrowserItemConfig{- "cloak": {Binary: "/opt/cloak/chrome"},- "chrome": {ExtraFlags: "--no-sandbox"},- },},}errs := ValidateFileConfig(fc)@@ -155,42 +159,6 @@ func TestValidateBrowsersBlock_AllPhase1Browsers(t *testing.T) {}}-func TestValidateBrowsersBlock_EmptyDefinition(t *testing.T) {- fc := &FileConfig{- Browsers: BrowsersConfig{- Default: "chrome",- Available: []string{"chrome", "cloak"},- Config: map[string]BrowserItemConfig{- "cloak": {},- },- },- }- errs := ValidateFileConfig(fc)- for _, e := range errs {- if strings.Contains(e.Error(), "browsers.") {- t.Fatalf("empty BrowserItemConfig should be valid, got: %v", e)- }- }-}--func TestValidateBrowsersBlock_GhostChromeInConfig(t *testing.T) {- fc := &FileConfig{- Browsers: BrowsersConfig{- Default: "chrome",- Available: []string{"chrome", "ghost-chrome"},- Config: map[string]BrowserItemConfig{- "ghost-chrome": {},- },- },- }- errs := ValidateFileConfig(fc)- for _, e := range errs {- if strings.Contains(e.Error(), "browsers.") {- t.Fatalf("ghost-chrome as config key should be valid, got: %v", e)- }- }-}-func TestValidateBrowsersBlock_EmptyConfigMap(t *testing.T) {fc := &FileConfig{Browsers: BrowsersConfig{@@ -337,3 +305,20 @@ func TestBrowsersBlock_GhostChromeLoaded(t *testing.T) {t.Errorf("BrowsersAvailable = %v, missing ghost-chrome", cfg.BrowsersAvailable)}}++// M1 regression: known providers validate case-insensitively, matching+// target-provider validation semantics.+func TestValidateBrowsersBlock_CaseInsensitiveKnownBrowsers(t *testing.T) {+ fc := &FileConfig{+ Browsers: BrowsersConfig{+ Default: "Cloak",+ Available: []string{"CHROME", "Cloak"},+ },+ }+ errs := ValidateFileConfig(fc)+ for _, e := range errs {+ if strings.Contains(e.Error(), "unknown browser") {+ t.Fatalf("mixed-case known browsers should validate, got: %v", e)+ }+ }+}diff --git a/internal/config/cloak_roundtrip_test.go b/internal/config/cloak_roundtrip_test.goindex 4ca01350..b0927c0e 100644--- a/internal/config/cloak_roundtrip_test.go+++ b/internal/config/cloak_roundtrip_test.go@@ -10,6 +10,9 @@ import ()func TestCloakChildConfigRoundTrip(t *testing.T) {+ // Isolate from the developer's real config: the first Load must read+ // defaults, not whatever ~/.pinchtab or PINCHTAB_CONFIG points at.+ t.Setenv("PINCHTAB_CONFIG", filepath.Join(t.TempDir(), "absent.json"))// Step 1: Simulate the orchestrator's RuntimeConfig with DefaultBrowser = "cloak"cfg := config.Load()cfg.DefaultBrowser = "cloak"@@ -74,6 +77,9 @@ func TestCloakChildConfigRoundTrip(t *testing.T) {}func TestCloakTargetResolution(t *testing.T) {+ // Isolate from the developer's real config: the first Load must read+ // defaults, not whatever ~/.pinchtab or PINCHTAB_CONFIG points at.+ t.Setenv("PINCHTAB_CONFIG", filepath.Join(t.TempDir(), "absent.json"))// Simulate what happens when a cloak E2E config is loaded:// browsers.default = "cloak" but browser.provider is NOT set.// The legacy migration must use browsers.default as the provider.diff --git a/internal/config/config_file_marshal.go b/internal/config/config_file_marshal.goindex b42ef6af..0713f8d5 100644--- a/internal/config/config_file_marshal.go+++ b/internal/config/config_file_marshal.go@@ -139,6 +139,9 @@ func tabPolicyDefaultsFromRuntime(cfg *RuntimeConfig) *TabPolicyDefaults {return out}+// browsersConfigJSONFromFile copies the browsers block for serialization. The+// retired Config map is still copied for round-trip byte fidelity even though+// validation rejects it — we warn, we don't destroy user input.func browsersConfigJSONFromFile(bc BrowsersConfig) *BrowsersConfig {if bc.Default == "" && len(bc.Available) == 0 && len(bc.Config) == 0 {return nil@@ -604,9 +607,11 @@ func FileConfigFromRuntime(cfg *RuntimeConfig) FileConfig {// orchestrator selecting cloak for a child instance) without rewriting Targets,// the stale target would otherwise shadow browsers.default on reload because// explicit targets win over the legacy fields. Only the lone auto-synthesized-// "default" target is reconciled; explicit multi-target configs are left intact.+// "default" target is reconciled; user-authored targets (single or multi) are+// left intact — rewriting them would flip the user's provider and wipe+// target-scoped binary/flags/cloak/proxy with global runtime values.func reconcileDefaultTargetProvider(bc *BrowserConfig, browsersDefault string, cfg *RuntimeConfig) {- if bc == nil || cfg == nil || len(bc.Targets) != 1 {+ if bc == nil || cfg == nil || !cfg.TargetsSynthesized || len(bc.Targets) != 1 {return}target, ok := bc.Targets[DefaultBrowserTargetName]diff --git a/internal/config/config_load.go b/internal/config/config_load.goindex d6258420..552301ae 100644--- a/internal/config/config_load.go+++ b/internal/config/config_load.go@@ -446,22 +446,39 @@ func applyFileConfig(cfg *RuntimeConfig, fc *FileConfig) {}// Migration shim must run before consuming legacy provider/binary/cloak fields below.- if synthesized, conflict := migrateLegacyBrowserConfig(&fc.Browser, fc.Browsers.Default); conflict {- slog.Warn("config has both browser.targets and legacy browser.provider/binary/cloak set; explicit targets win, legacy fields ignored for target resolution")+ synthesized, conflict := migrateLegacyBrowserConfig(&fc.Browser, fc.Browsers.Default)+ if conflict {+ slog.Warn("config has both browser.targets and legacy browser.binary/extraFlags/cloak/proxy set; targets are used as authored (no legacy synthesis), but the legacy fields still seed the base runtime config that target resolution overlays per-field")} else if synthesized {slog.Debug("migrated legacy browser config into browser.targets.default")}- if len(fc.Browser.Targets) > 0 {- cfg.Targets = cloneBrowserTargetsConfig(fc.Browser.Targets)- cfg.DefaultTarget = fc.Browser.DefaultTarget- cfg.FallbackOrder = append([]string(nil), fc.Browser.FallbackOrder...)- }+ // Assigned unconditionally — unlike most fields below, which only apply+ // when present, a reload must be able to REMOVE targets: stale routing+ // (and the proxy credentials inside targets) staying live after the user+ // deleted them is dangerous. Absent blocks clear to zero values; the+ // migration shim above re-synthesizes targets for legacy-only files first.+ cfg.Targets = cloneBrowserTargetsConfig(fc.Browser.Targets)+ cfg.DefaultTarget = fc.Browser.DefaultTarget+ cfg.FallbackOrder = append([]string(nil), fc.Browser.FallbackOrder...)+ cfg.TargetsSynthesized = synthesized && len(fc.Browser.Targets) > 0// Resolve the effective browser provider: browsers.default is the// authoritative source. browser.provider and server.engine are no longer- // supported (rejected at validation time).+ // supported (rejected at validation time), so a target synthesized from+ // those legacy fields must not select the provider either. A USER-AUTHORED+ // default target, however, is the user's provider choice — forcing chrome+ // would contradict it and destructively "reconcile" it on the next+ // FileConfigFromRuntime round-trip.if fc.Browsers.Default != "" {cfg.DefaultBrowser = fc.Browsers.Default+ // Launch paths coerce unknown providers to chrome via+ // NormalizeBrowser; name that consequence loudly at load time.+ if _, ok := browsers.Get(strings.ToLower(strings.TrimSpace(fc.Browsers.Default))); !ok {+ slog.Warn("browsers.default is not a known browser; launches will fall back to chrome",+ "configured", fc.Browsers.Default, "known", browsers.IDs())+ }+ } else if name := ResolveDefaultTarget(cfg); name != "" && !cfg.TargetsSynthesized && cfg.Targets[name].Provider != "" {+ cfg.DefaultBrowser = NormalizeBrowser(cfg.Targets[name].Provider)} else {cfg.DefaultBrowser = "chrome"}@@ -484,17 +501,19 @@ func applyFileConfig(cfg *RuntimeConfig, fc *FileConfig) {cfg.BrowserExtraFlags = SanitizeBrowserExtraFlags(fc.Browser.BrowserExtraFlags)}applyCloakBrowserConfigToRuntime(cfg, fc.Browser.Cloak)- if !fc.Browser.Proxy.IsZero() {- cfg.Proxy = BrowserProxyConfig{- Server: fc.Browser.Proxy.Server,- BypassList: append([]string(nil), fc.Browser.Proxy.BypassList...),- Username: fc.Browser.Proxy.Username,- Password: fc.Browser.Proxy.Password,- }- if fc.Browser.Proxy.Geo != nil {- geoCopy := *fc.Browser.Proxy.Geo- cfg.Proxy.Geo = &geoCopy- }+ // Assigned unconditionally (see Targets above): removing browser.proxy+ // from the file must clear the runtime proxy — leaving stale credentials+ // live in a long-running process is worse than the asymmetry with the+ // presence-guarded fields around this one.+ cfg.Proxy = BrowserProxyConfig{+ Server: fc.Browser.Proxy.Server,+ BypassList: append([]string(nil), fc.Browser.Proxy.BypassList...),+ Username: fc.Browser.Proxy.Username,+ Password: fc.Browser.Proxy.Password,+ }+ if fc.Browser.Proxy.Geo != nil {+ geoCopy := *fc.Browser.Proxy.Geo+ cfg.Proxy.Geo = &geoCopy}if fc.Browser.ExtensionPaths != nil {cfg.ExtensionPaths = append([]string(nil), fc.Browser.ExtensionPaths...)diff --git a/internal/config/config_load_test.go b/internal/config/config_load_test.goindex 55a74131..37353127 100644--- a/internal/config/config_load_test.go+++ b/internal/config/config_load_test.go@@ -1,7 +1,9 @@package configimport (+ "bytes""encoding/json"+ "log/slog""os""path/filepath""strings"@@ -928,6 +930,99 @@ func writeTestConfig(t *testing.T, body string) {t.Cleanup(func() { _ = os.Unsetenv("PINCHTAB_CONFIG") })}+// Pins the precedence contract when both legacy browser fields and explicit+// browser.targets are set: targets are kept as authored (no legacy synthesis),+// the legacy fields still seed the base runtime config, and target resolution+// overlays target fields per-field on top of that base.+func TestLoadConfig_LegacyAndTargetsBothSet_PrecedenceContract(t *testing.T) {+ clearConfigEnvVars(t)+ writeTestConfig(t, `{+ "browser": {+ "binary": "/legacy/bin/chrome",+ "extraFlags": "--disable-gpu",+ "proxy": {"server": "http://legacy-proxy.example:8080"},+ "defaultTarget": "default",+ "targets": {+ "default": {+ "provider": "chrome",+ "binary": "/target/bin/chrome",+ "proxy": {"server": "http://target-proxy.example:9090"}+ }+ }+ }+ }`)++ var warned bool+ logs := captureConfigSlog(t, func() {+ cfg := Load()++ if cfg.TargetsSynthesized {+ t.Errorf("TargetsSynthesized = true, want false (explicit targets must not be marked as migrated)")+ }+ target, ok := cfg.Targets["default"]+ if !ok {+ t.Fatalf("Targets missing authored default entry: %v", cfg.Targets)+ }+ if target.Binary != "/target/bin/chrome" {+ t.Errorf("target Binary = %q, want authored /target/bin/chrome", target.Binary)+ }++ // Legacy fields seed the BASE runtime config.+ if cfg.BrowserBinary != "/legacy/bin/chrome" {+ t.Errorf("base BrowserBinary = %q, want legacy /legacy/bin/chrome", cfg.BrowserBinary)+ }+ if cfg.BrowserExtraFlags != "--disable-gpu" {+ t.Errorf("base BrowserExtraFlags = %q, want legacy --disable-gpu", cfg.BrowserExtraFlags)+ }+ if cfg.Proxy.Server != "http://legacy-proxy.example:8080" {+ t.Errorf("base Proxy.Server = %q, want legacy proxy", cfg.Proxy.Server)+ }++ // A user-authored default target supplies the provider.+ if cfg.DefaultBrowser != BrowserChrome {+ t.Errorf("DefaultBrowser = %q, want %s from the authored target", cfg.DefaultBrowser, BrowserChrome)+ }++ // Target resolution overlays target fields on the legacy-seeded base.+ resolved, err := ResolveDefaultBrowserTarget(cfg)+ if err != nil {+ t.Fatalf("ResolveDefaultBrowserTarget returned %v", err)+ }+ if resolved.Legacy {+ t.Errorf("resolved.Legacy = true, want false with explicit targets")+ }+ if resolved.Config.BrowserBinary != "/target/bin/chrome" {+ t.Errorf("resolved Binary = %q, want target /target/bin/chrome", resolved.Config.BrowserBinary)+ }+ if resolved.Config.Proxy.Server != "http://target-proxy.example:9090" {+ t.Errorf("resolved Proxy.Server = %q, want target proxy", resolved.Config.Proxy.Server)+ }+ // Fields the target omits fall back to the legacy base.+ if resolved.Config.BrowserExtraFlags != "--disable-gpu" {+ t.Errorf("resolved BrowserExtraFlags = %q, want legacy --disable-gpu fallback", resolved.Config.BrowserExtraFlags)+ }+ })+ warned = strings.Contains(logs, "config has both browser.targets and legacy")+ if !warned {+ t.Errorf("expected conflict warning in logs, got: %s", logs)+ }+ if strings.Contains(logs, "legacy fields ignored") {+ t.Errorf("warning still claims legacy fields are ignored; they seed the base runtime config: %s", logs)+ }+}++// captureConfigSlog redirects the default slog logger to a buffer for the+// duration of fn and returns everything logged.+func captureConfigSlog(t *testing.T, fn func()) string {+ t.Helper()+ var buf bytes.Buffer+ old := slog.Default()+ slog.SetDefault(slog.New(slog.NewTextHandler(&buf, nil)))+ defer slog.SetDefault(old)+ fn()+ return buf.String()+}+func TestLoadConfig_TabLifecycleDefaults(t *testing.T) {clearConfigEnvVars(t)_ = os.Setenv("PINCHTAB_CONFIG", filepath.Join(t.TempDir(), "nonexistent.json"))@@ -1043,3 +1138,68 @@ func TestLoadConfig_DefaultBrowsersNeverIncludesHighTrust(t *testing.T) {t.Errorf("DefaultBrowser = %q, want chrome", cfg.DefaultBrowser)}}++// M3 regression: a reload must be able to REMOVE targets and proxy — stale+// routing and credentials must not survive deletion from the file.+func TestApplyFileConfig_ReloadClearsRemovedProxyAndTargets(t *testing.T) {+ cfg := &RuntimeConfig{}++ withBlocks := &FileConfig{+ Browser: BrowserConfig{+ DefaultTarget: "cloak-1",+ FallbackOrder: []string{"cloak-1"},+ Targets: BrowserTargetsConfig{+ "cloak-1": {Provider: BrowserCloak, Binary: "/opt/cloak/bin"},+ },+ Proxy: BrowserProxyConfig{+ Server: "http://proxy.example:8080",+ Username: "user",+ Password: "secret",+ },+ },+ }+ applyFileConfig(cfg, withBlocks)+ if len(cfg.Targets) == 0 || cfg.Proxy.IsZero() {+ t.Fatalf("setup failed: targets=%v proxy=%+v", cfg.Targets, cfg.Proxy.Redacted())+ }++ without := &FileConfig{}+ applyFileConfig(cfg, without)++ if len(cfg.Targets) != 0 {+ t.Fatalf("targets not cleared on reload: %v", cfg.Targets)+ }+ if cfg.DefaultTarget != "" || len(cfg.FallbackOrder) != 0 {+ t.Fatalf("defaultTarget/fallbackOrder not cleared: %q %v", cfg.DefaultTarget, cfg.FallbackOrder)+ }+ if cfg.TargetsSynthesized {+ t.Fatal("TargetsSynthesized should clear with the targets")+ }+ if !cfg.Proxy.IsZero() {+ t.Fatalf("proxy (and credentials) not cleared on reload: %+v", cfg.Proxy.Redacted())+ }+}++func TestApplyFileConfig_ReloadLegacyOnlyStillSynthesizesTargets(t *testing.T) {+ cfg := &RuntimeConfig{}+ applyFileConfig(cfg, &FileConfig{+ Browser: BrowserConfig{+ Targets: BrowserTargetsConfig{"cloak-1": {Provider: BrowserCloak}},+ },+ })++ legacyOnly := &FileConfig{+ Browser: BrowserConfig{BrowserBinary: "/usr/bin/chrome"},+ }+ applyFileConfig(cfg, legacyOnly)++ if len(cfg.Targets) == 0 {+ t.Fatal("legacy-only reload should re-synthesize targets via the migration shim")+ }+ if !cfg.TargetsSynthesized {+ t.Fatal("re-synthesized targets should be marked synthesized")+ }+ if _, ok := cfg.Targets[DefaultBrowserTargetName]; !ok {+ t.Fatalf("expected synthesized default target, got %v", cfg.Targets)+ }+}diff --git a/internal/config/config_types.go b/internal/config/config_types.goindex b4cf938b..8ad0a18f 100644--- a/internal/config/config_types.go+++ b/internal/config/config_types.go@@ -70,14 +70,19 @@ type RuntimeConfig struct {// agent to drive the user's actual Chrome (extensions, profile, signed-in// state) rather than a fresh isolated profile. Cleanup never kills the// external Chrome — pinchtab only owns the CDP connection.- CDPAttachURL string- Cloak CloakBrowserRuntimeConfig- Proxy BrowserProxyConfig- DefaultBrowser string- BrowsersAvailable []string- Targets BrowserTargetsConfig- DefaultTarget string- FallbackOrder []string+ CDPAttachURL string+ Cloak CloakBrowserRuntimeConfig+ Proxy BrowserProxyConfig+ DefaultBrowser string+ BrowsersAvailable []string+ Targets BrowserTargetsConfig+ DefaultTarget string+ FallbackOrder []string+ // TargetsSynthesized marks Targets as auto-migrated from legacy+ // browser.binary/cloak/proxy fields rather than user-authored; only+ // synthesized targets may be rewritten by provider reconciliation on+ // serialization. Load-time bookkeeping, never serialized.+ TargetsSynthesized boolExtensionPaths []stringUserAgent stringNoAnimations bool@@ -364,8 +369,10 @@ type BrowsersConfig struct {Config map[string]BrowserItemConfig `json:"config,omitempty"`}-// BrowserItemConfig holds per-browser configuration overrides within the-// browsers.config map.+// BrowserItemConfig holds the retired browsers.config per-browser overrides.+// The block was never applied anywhere and is superseded by browser.targets;+// it is parsed only so validation can reject it with guidance and so existing+// files round-trip byte-for-byte.type BrowserItemConfig struct {Binary string `json:"binary,omitempty"`ExtraFlags string `json:"extraFlags,omitempty"`diff --git a/internal/config/editor_get.go b/internal/config/editor_get.goindex 64124665..3b5dccf9 100644--- a/internal/config/editor_get.go+++ b/internal/config/editor_get.go@@ -65,6 +65,12 @@ func getBrowserField(b *BrowserConfig, field string) (string, error) {if strings.HasPrefix(field, "cloak.") {return getCloakBrowserField(&b.Cloak, strings.TrimPrefix(field, "cloak."))}+ if strings.HasPrefix(field, "proxy.") {+ return getBrowserProxyField(&b.Proxy, strings.TrimPrefix(field, "proxy."))+ }+ if strings.HasPrefix(field, "targets.") {+ return getBrowserTargetField(b.Targets, strings.TrimPrefix(field, "targets."))+ }switch field {case "provider":return "", fmt.Errorf("browser.provider is no longer supported; use browsers.default")@@ -74,11 +80,74 @@ func getBrowserField(b *BrowserConfig, field string) (string, error) {return b.BrowserBinary, nilcase "extraFlags":return b.BrowserExtraFlags, nil+ case "defaultTarget":+ return b.DefaultTarget, nil+ case "fallbackOrder":+ return strings.Join(b.FallbackOrder, ","), nildefault:return "", fmt.Errorf("unknown field browser.%s", field)}}+// getBrowserProxyField returns proxy values plainly — like server.token, the+// CLI editor reads the operator's own file.+func getBrowserProxyField(p *BrowserProxyConfig, field string) (string, error) {+ if strings.HasPrefix(field, "geo.") {+ if p.Geo == nil {+ return "", nil+ }+ switch strings.TrimPrefix(field, "geo.") {+ case "timezone":+ return p.Geo.Timezone, nil+ case "locale":+ return p.Geo.Locale, nil+ case "webrtcIP":+ return p.Geo.WebRTCIP, nil+ case "countryISO":+ return p.Geo.CountryISO, nil+ default:+ return "", fmt.Errorf("unknown field proxy.%s", field)+ }+ }+ switch field {+ case "server":+ return p.Server, nil+ case "bypassList":+ return strings.Join(p.BypassList, ","), nil+ case "username":+ return p.Username, nil+ case "password":+ return p.Password, nil+ default:+ return "", fmt.Errorf("unknown field proxy.%s", field)+ }+}++func getBrowserTargetField(targets BrowserTargetsConfig, path string) (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)+ }+ t, ok := targets[name]+ if !ok {+ return "", fmt.Errorf("browser target %q not found", name)+ }+ switch {+ case strings.HasPrefix(field, "cloak."):+ return getCloakBrowserField(&t.Cloak, strings.TrimPrefix(field, "cloak."))+ case strings.HasPrefix(field, "proxy."):+ return getBrowserProxyField(&t.Proxy, strings.TrimPrefix(field, "proxy."))+ case field == "provider":+ return t.Provider, nil+ case field == "binary":+ return t.Binary, nil+ case field == "extraFlags":+ return t.ExtraFlags, nil+ default:+ return "", fmt.Errorf("unknown field browser.targets.%s.%s", name, field)+ }+}+func getBrowsersField(b *BrowsersConfig, field string) (string, error) {switch field {case "default":diff --git a/internal/config/editor_set.go b/internal/config/editor_set.goindex 6b49e3a2..b68c573c 100644--- a/internal/config/editor_set.go+++ b/internal/config/editor_set.go@@ -4,6 +4,8 @@ import ("fmt""strconv""strings"++ "github.com/pinchtab/pinchtab/internal/browsers")// SetConfigValue sets a dotted path in FileConfig (e.g., "server.port", "instanceDefaults.mode").@@ -79,6 +81,12 @@ 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")@@ -88,6 +96,10 @@ func setBrowserField(b *BrowserConfig, field, value string) error {b.BrowserBinary = valuecase "extraFlags":b.BrowserExtraFlags = value+ case "defaultTarget":+ b.DefaultTarget = value+ case "fallbackOrder":+ b.FallbackOrder = parseCSVList(value)default:return fmt.Errorf("unknown field browser.%s", field)}@@ -97,7 +109,11 @@ func setBrowserField(b *BrowserConfig, field, value string) error {func setBrowsersField(b *BrowsersConfig, field, value string) error {switch field {case "default":- b.Default = value+ 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 = idcase "available":b.Available = parseCSVList(value)default:@@ -106,6 +122,78 @@ func setBrowsersField(b *BrowsersConfig, field, value string) error {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":diff --git a/internal/config/editor_set_test.go b/internal/config/editor_set_test.goindex a097f5c7..f1a3d060 100644--- a/internal/config/editor_set_test.go+++ b/internal/config/editor_set_test.go@@ -343,3 +343,55 @@ func TestSetConfigValue_InvalidPaths(t *testing.T) {})}}++// L6: editor coverage for the browser-targets feature surfaces.+func TestSetGetBrowserTargetAndProxyFields(t *testing.T) {+ fc := &FileConfig{}+ sets := map[string]string{+ "browser.defaultTarget": "cloak-eu",+ "browser.fallbackOrder": "cloak-eu,chrome-local",+ "browser.proxy.server": "http://proxy.example:8080",+ "browser.proxy.geo.timezone": "Europe/Paris",+ "browser.targets.cloak-eu.provider": "cloak",+ "browser.targets.cloak-eu.binary": "/opt/cloak/bin",+ "browser.targets.cloak-eu.cloak.fingerprintSeed": "42069",+ "browser.targets.cloak-eu.proxy.password": "secret",+ }+ for path, value := range sets {+ if err := SetConfigValue(fc, path, value); err != nil {+ t.Fatalf("SetConfigValue(%s): %v", path, err)+ }+ }+ for path, want := range sets {+ got, err := GetConfigValue(fc, path)+ if err != nil {+ t.Fatalf("GetConfigValue(%s): %v", path, err)+ }+ if got != want {+ t.Fatalf("GetConfigValue(%s) = %q, want %q", path, got, want)+ }+ }++ if err := SetConfigValue(fc, "browser.targets.cloak-eu.bogus", "x"); err == nil {+ t.Fatal("unknown target field should error")+ }+ if err := SetConfigValue(fc, "browser.targets.Bad-Name.binary", "/x"); err == nil {+ t.Fatal("invalid target name should error")+ }+ if _, err := GetConfigValue(fc, "browser.targets.missing.binary"); err == nil {+ t.Fatal("missing target should error on get")+ }+}++func TestSetBrowsersDefaultRejectsUnknownBrowser(t *testing.T) {+ fc := &FileConfig{}+ if err := SetConfigValue(fc, "browsers.default", "cloack"); err == nil {+ t.Fatal("typo'd browsers.default should be rejected")+ }+ if err := SetConfigValue(fc, "browsers.default", "Cloak"); err != nil {+ t.Fatalf("mixed-case known browser should normalize: %v", err)+ }+ if fc.Browsers.Default != "cloak" {+ t.Fatalf("Default = %q, want normalized cloak", fc.Browsers.Default)+ }+}diff --git a/internal/config/validate.go b/internal/config/validate.goindex 8402f515..b8e1817c 100644--- a/internal/config/validate.go+++ b/internal/config/validate.go@@ -621,16 +621,18 @@ func validateBrowsersBlock(fc FileConfig) []error {var errs []error- // Validate default is a known browser+ // Validate default is a known browser. The registry is keyed by lowercase+ // IDs; trim+lowercase like target validation does so "Cloak" validates+ // the same everywhere.if bc.Default != "" {- if _, ok := browsers.Get(bc.Default); !ok {+ if _, ok := browsers.Get(strings.ToLower(strings.TrimSpace(bc.Default))); !ok {errs = append(errs, fmt.Errorf("browsers.default: unknown browser %q (known: %v)", bc.Default, browsers.IDs()))}}// Validate each entry in availablefor i, name := range bc.Available {- if _, ok := browsers.Get(name); !ok {+ if _, ok := browsers.Get(strings.ToLower(strings.TrimSpace(name))); !ok {errs = append(errs, fmt.Errorf("browsers.available[%d]: unknown browser %q (known: %v)", i, name, browsers.IDs()))}}@@ -649,11 +651,11 @@ func validateBrowsersBlock(fc FileConfig) []error {}}- // Validate config keys are known browsers- for name := range bc.Config {- if _, ok := browsers.Get(name); !ok {- errs = append(errs, fmt.Errorf("browsers.config: unknown browser %q (known: %v)", name, browsers.IDs()))- }+ // browsers.config was accepted but never applied anywhere; reject it with+ // guidance (mirroring the browser.provider retirement) rather than letting+ // the overrides be silently ignored.+ if len(bc.Config) > 0 {+ errs = append(errs, fmt.Errorf("browsers.config is no longer supported; use browser.targets.<name> instead (e.g. \"browser\": {\"targets\": {\"cloak\": {\"binary\": \"/opt/cloak/bin\"}}})"))}return errsdiff --git a/internal/schema/config.json b/internal/schema/config.jsonindex 5db9a627..3e2b3a3b 100644--- a/internal/schema/config.json+++ b/internal/schema/config.json@@ -249,6 +249,24 @@},"extensionPaths": {"$ref": "#/definitions/stringArray"+ },+ "proxy": {+ "$ref": "#/definitions/browserProxy"+ },+ "defaultTarget": {+ "type": "string",+ "description": "Name of the target used when no browser is requested."+ },+ "fallbackOrder": {+ "$ref": "#/definitions/stringArray",+ "description": "Target names tried in order when an implicit launch fails."+ },+ "targets": {+ "type": "object",+ "description": "Named browser targets keyed by target name.",+ "additionalProperties": {+ "$ref": "#/definitions/browserTarget"+ }}}},@@ -1000,7 +1018,11 @@"default": {"type": "string","description": "Default browser for new instances.",- "enum": ["chrome", "ghost-chrome", "cloak"],+ "enum": [+ "chrome",+ "ghost-chrome",+ "cloak"+ ],"default": "chrome"},"available": {@@ -1008,48 +1030,90 @@"description": "Available browser names.","items": {"type": "string",- "enum": ["chrome", "ghost-chrome", "cloak"]+ "enum": [+ "chrome",+ "ghost-chrome",+ "cloak"+ ]}+ }+ }+ },+ "browserProxy": {+ "type": "object",+ "description": "Upstream proxy for browser traffic. Credentials are delivered via CDP, never on the command line.",+ "additionalProperties": false,+ "properties": {+ "server": {+ "type": "string",+ "description": "Proxy server URL (e.g. http://proxy.example:8080)."+ },+ "bypassList": {+ "$ref": "#/definitions/stringArray",+ "description": "Hosts that bypass the proxy."+ },+ "username": {+ "type": "string",+ "description": "Proxy username."+ },+ "password": {+ "type": "string",+ "description": "Proxy password. Redacted in API responses."},- "config": {+ "geo": {"type": "object",- "description": "Per-browser configuration overrides.",- "additionalProperties": {- "type": "object",- "properties": {- "binary": {- "type": "string",- "description": "Path to browser binary."- },- "extraFlags": {- "type": "string",- "description": "Additional launch flags."- },- "cloak": {- "$ref": "#/definitions/cloakBrowser"- },- "proxy": {- "type": "object",- "description": "Per-browser proxy configuration.",- "properties": {- "server": {- "type": "string"- },- "bypassList": {- "$ref": "#/definitions/stringArray"- },- "username": {- "type": "string"- },- "password": {- "type": "string"- }- }- }+ "description": "Geo alignment hints applied when the proxy egress is in another region.",+ "additionalProperties": false,+ "properties": {+ "timezone": {+ "type": "string",+ "description": "IANA timezone matching the proxy egress (e.g. Europe/Paris)."+ },+ "locale": {+ "type": "string",+ "description": "BCP-47 locale matching the proxy egress (e.g. fr-FR)."+ },+ "webrtcIP": {+ "type": "string",+ "description": "Public IP to expose via WebRTC instead of the local address."+ },+ "countryISO": {+ "type": "string",+ "description": "ISO 3166-1 alpha-2 country code of the proxy egress."}}}}+ },+ "browserTarget": {+ "type": "object",+ "description": "A named browser target: a provider plus per-target overrides.",+ "additionalProperties": false,+ "properties": {+ "provider": {+ "type": "string",+ "description": "Browser provider for this target.",+ "enum": [+ "chrome",+ "ghost-chrome",+ "cloak"+ ]+ },+ "binary": {+ "type": "string",+ "description": "Path to the browser binary for this target."+ },+ "extraFlags": {+ "type": "string",+ "description": "Additional space-separated browser flags for this target."+ },+ "cloak": {+ "$ref": "#/definitions/cloakBrowser"+ },+ "proxy": {+ "$ref": "#/definitions/browserProxy"+ }+ }}}}diff --git a/internal/schema/schema_test.go b/internal/schema/schema_test.goindex d98f262a..1f2ce8f2 100644--- a/internal/schema/schema_test.go+++ b/internal/schema/schema_test.go@@ -2,6 +2,8 @@ package schemaimport ("encoding/json"+ "reflect"+ "strings""testing""github.com/pinchtab/pinchtab/internal/config"@@ -55,3 +57,94 @@ func TestConfigJSONForURL(t *testing.T) {t.Fatalf("config $schema default = %q, want %q", schemaProp["default"], schemaURL)}}++// Every JSON tag of the browser-config structs must exist in the schema —+// additionalProperties:false means a missing property rejects valid configs+// in $schema-aware tooling (H10a regression).+func TestConfigSchemaCoversBrowserConfigFields(t *testing.T) {+ var raw struct {+ Definitions map[string]struct {+ Properties map[string]json.RawMessage `json:"properties"`+ } `json:"definitions"`+ }+ if err := json.Unmarshal(ConfigJSON, &raw); err != nil {+ t.Fatalf("ConfigJSON is not valid JSON: %v", err)+ }++ cases := []struct {+ definition string+ structType reflect.Type+ }{+ {"browser", reflect.TypeOf(config.BrowserConfig{})},+ {"browserTarget", reflect.TypeOf(config.BrowserTargetConfig{})},+ {"browserProxy", reflect.TypeOf(config.BrowserProxyConfig{})},+ }+ for _, tc := range cases {+ def, ok := raw.Definitions[tc.definition]+ if !ok {+ t.Errorf("schema missing definition %q", tc.definition)+ continue+ }+ for _, tag := range jsonTags(tc.structType) {+ if _, ok := def.Properties[tag]; !ok {+ t.Errorf("definitions.%s missing property %q (from %s)", tc.definition, tag, tc.structType.Name())+ }+ }+ }++ // Geo nests under browserProxy.properties.geo.properties.+ var proxyDef struct {+ Properties struct {+ Geo struct {+ Properties map[string]json.RawMessage `json:"properties"`+ } `json:"geo"`+ } `json:"properties"`+ }+ var defsOnly map[string]json.RawMessage+ root := map[string]json.RawMessage{}+ if err := json.Unmarshal(ConfigJSON, &root); err != nil {+ t.Fatal(err)+ }+ if err := json.Unmarshal(root["definitions"], &defsOnly); err != nil {+ t.Fatal(err)+ }+ if err := json.Unmarshal(defsOnly["browserProxy"], &proxyDef); err != nil {+ t.Fatal(err)+ }+ for _, tag := range jsonTags(reflect.TypeOf(config.BrowserProxyGeoConfig{})) {+ if _, ok := proxyDef.Properties.Geo.Properties[tag]; !ok {+ t.Errorf("browserProxy.geo missing property %q", tag)+ }+ }+}++func jsonTags(t reflect.Type) []string {+ var tags []string+ for i := 0; i < t.NumField(); i++ {+ tag := t.Field(i).Tag.Get("json")+ if tag == "" || tag == "-" {+ continue+ }+ name := strings.Split(tag, ",")[0]+ if name != "" {+ tags = append(tags, name)+ }+ }+ return tags+}++// The retired browsers.config block must stay out of the schema so editors+// flag it; validation rejects it with browser.targets guidance.+func TestConfigSchemaOmitsRetiredBrowsersConfig(t *testing.T) {+ var raw struct {+ Definitions map[string]struct {+ Properties map[string]json.RawMessage `json:"properties"`+ } `json:"definitions"`+ }+ if err := json.Unmarshal(ConfigJSON, &raw); err != nil {+ t.Fatalf("ConfigJSON is not valid JSON: %v", err)+ }+ if _, ok := raw.Definitions["browsers"].Properties["config"]; ok {+ t.Fatal("definitions.browsers must not advertise the retired config block")+ }+}