Skip to content

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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 55a74131..37353127 100644
--- a/internal/config/config_load_test.go
+++ b/internal/config/config_load_test.go
@@ -1,7 +1,9 @@
package config
import (
+ "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.go
index 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 bool
ExtensionPaths []string
UserAgent string
NoAnimations 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.go
index 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, nil
case "extraFlags":
return b.BrowserExtraFlags, nil
+ case "defaultTarget":
+ return b.DefaultTarget, nil
+ case "fallbackOrder":
+ return strings.Join(b.FallbackOrder, ","), nil
default:
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.go
index 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 = value
case "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 = id
case "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.go
index 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.go
index 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 available
for 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 errs
diff --git a/internal/schema/config.json b/internal/schema/config.json
index 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.go
index d98f262a..1f2ce8f2 100644
--- a/internal/schema/schema_test.go
+++ b/internal/schema/schema_test.go
@@ -2,6 +2,8 @@ package schema
import (
"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")
+ }
+}