High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
feat(autosolver): add challenge detection and handler integration
Mario7aecc8dceb6c
diff --git a/internal/autosolver/adapters/pinchtab.go b/internal/autosolver/adapters/pinchtab.goindex 76b893b4..7a555250 100644--- a/internal/autosolver/adapters/pinchtab.go+++ b/internal/autosolver/adapters/pinchtab.go@@ -13,15 +13,20 @@ import ("github.com/pinchtab/pinchtab/internal/bridge")+var (+ _ autosolver.Page = (*PinchtabPage)(nil)+ _ autosolver.ActionExecutor = (*PinchtabExecutor)(nil)+)+// PinchtabPage implements autosolver.Page by wrapping a chromedp tab context.type PinchtabPage struct {ctx context.ContexttabID string- b *bridge.Bridge+ b bridge.BridgeAPI}// NewPinchtabPage creates a Page backed by a Pinchtab bridge tab.-func NewPinchtabPage(ctx context.Context, tabID string, b *bridge.Bridge) *PinchtabPage {+func NewPinchtabPage(ctx context.Context, tabID string, b bridge.BridgeAPI) *PinchtabPage {return &PinchtabPage{ctx: ctx, tabID: tabID, b: b}}@@ -61,11 +66,11 @@ func (p *PinchtabPage) Screenshot() ([]byte, error) {type PinchtabExecutor struct {ctx context.ContexttabID string- b *bridge.Bridge+ b bridge.BridgeAPI}// NewPinchtabExecutor creates an ActionExecutor backed by a Pinchtab bridge.-func NewPinchtabExecutor(ctx context.Context, tabID string, b *bridge.Bridge) *PinchtabExecutor {+func NewPinchtabExecutor(ctx context.Context, tabID string, b bridge.BridgeAPI) *PinchtabExecutor {return &PinchtabExecutor{ctx: ctx, tabID: tabID, b: b}}@@ -94,7 +99,7 @@ func (e *PinchtabExecutor) Navigate(ctx context.Context, url string) error {// NewFromBridge creates both a Page and ActionExecutor from a Bridge// and tab ID. This is the primary factory for integration with Pinchtab.-func NewFromBridge(b *bridge.Bridge, tabID string) (autosolver.Page, autosolver.ActionExecutor, error) {+func NewFromBridge(b bridge.BridgeAPI, tabID string) (autosolver.Page, autosolver.ActionExecutor, error) {tabCtx, resolvedID, err := b.TabContext(tabID)if err != nil {return nil, nil, fmt.Errorf("resolve tab %q: %w", tabID, err)diff --git a/internal/autosolver/autosolver.go b/internal/autosolver/autosolver.goindex 64905561..a24fa099 100644--- a/internal/autosolver/autosolver.go+++ b/internal/autosolver/autosolver.go@@ -4,12 +4,14 @@ import ("context""fmt""log/slog"+ "os"+ "sort""time")// AutoSolver orchestrates the challenge-detection and solving pipeline.-// It uses a fallback chain: built-in solvers → semantic engine → external-// solvers → LLM provider, trying each layer before moving to the next.+// It uses a fallback chain: semantic engine (/find + self-healing) ->+// rule-based solvers -> external solvers -> LLM provider.type AutoSolver struct {registry *Registrysemantic SemanticEngine@@ -38,9 +40,10 @@ func (as *AutoSolver) Registry() *Registry {// Steps:// 1. Detect intent via semantic engine (or title-based heuristics)// 2. If no challenge detected, return immediately-// 3. Try matching solvers in priority order-// 4. If all fail and LLM is enabled, try LLM fallback-// 5. Return result with full attempt history+// 3. Try semantic-first action (/find + self-healing)+// 4. If semantic fails, try matching solvers in priority order+// 5. If all fail and LLM is enabled, try LLM fallback+// 6. Return result with full attempt historyfunc (as *AutoSolver) Solve(ctx context.Context, page Page, executor ActionExecutor) (*Result, error) {start := time.Now()result := &Result{@@ -63,7 +66,7 @@ func (as *AutoSolver) Solve(ctx context.Context, page Page, executor ActionExecu}result.Intent = intent.Type- // No challenge — nothing to solve.+ // No challenge - nothing to solve.if intent.Type == IntentNormal {result.Solved = trueresult.TotalDuration = time.Since(start)@@ -105,8 +108,32 @@ func (as *AutoSolver) Solve(ctx context.Context, page Page, executor ActionExecu}}+ // Try semantic-first action before any rule-based solver.+ solved, entry := as.trySemantic(ctx, page, executor, intent)+ if entry != nil {+ result.History = append(result.History, *entry)+ }+ if solved {+ result.Solved = true+ result.SolverUsed = entry.Solver+ result.FinalTitle = page.Title()+ result.FinalURL = page.URL()+ result.TotalDuration = time.Since(start)+ slog.Info("autosolver_success",+ "solver", entry.Solver,+ "attempts", result.Attempts,+ "duration_ms", result.TotalDuration.Milliseconds(),+ "url", page.URL())+ slog.Info("autosolver_done",+ "solved", true,+ "solver", entry.Solver,+ "attempts", result.Attempts,+ "duration_ms", result.TotalDuration.Milliseconds())+ return result, nil+ }+// Try registered solvers in priority order.- solved, entry := as.trySolvers(ctx, page, executor)+ solved, entry = as.trySolvers(ctx, page, executor)if entry != nil {result.History = append(result.History, *entry)}@@ -131,7 +158,7 @@ func (as *AutoSolver) Solve(ctx context.Context, page Page, executor ActionExecu// Try LLM fallback if enabled and all solvers failed.if as.config.LLMFallback && as.llm != nil {- solved, entry := as.tryLLM(ctx, page, executor, result.History)+ solved, entry = as.tryLLM(ctx, page, executor, result.History)if entry != nil {result.History = append(result.History, *entry)}@@ -190,7 +217,44 @@ func (as *AutoSolver) trySolvers(ctx context.Context, page Page, executor Action}}- for _, s := range solvers {+ orderedSolvers := solvers+ if len(as.config.Solvers) > 0 {+ byName := make(map[string]Solver, len(solvers))+ for _, s := range solvers {+ byName[s.Name()] = s+ }++ filtered := make([]Solver, 0, len(as.config.Solvers))+ missing := make([]string, 0, len(as.config.Solvers))+ for _, name := range as.config.Solvers {+ if s, ok := byName[name]; ok {+ filtered = append(filtered, s)+ continue+ }+ missing = append(missing, name)+ }++ // If config names don't match available solvers, preserve default behavior.+ if len(filtered) > 0 {+ if len(missing) > 0 {+ slog.Debug("autosolver: some configured solvers unavailable; using matched subset",+ "configured", as.config.Solvers,+ "missing", missing)+ }+ orderedSolvers = filtered+ } else {+ available := make([]string, 0, len(byName))+ for name := range byName {+ available = append(available, name)+ }+ sort.Strings(available)+ slog.Debug("autosolver: configured solver order not found, using priority order",+ "configured", as.config.Solvers,+ "available", available)+ }+ }++ for _, s := range orderedSolvers {solverCtx, cancel := context.WithTimeout(ctx, as.config.SolverTimeout)solverStart := time.Now()@@ -231,12 +295,429 @@ func (as *AutoSolver) trySolvers(ctx context.Context, page Page, executor Action}return false, &AttemptEntry{- Solver: solvers[len(solvers)-1].Name(),+ Solver: orderedSolvers[len(orderedSolvers)-1].Name(),Status: StatusFailed,Error: "all matching solvers failed",}}+// trySemantic executes semantic /find-driven action planning first.+// For high-level intents it runs a small multi-step semantic flow.+func (as *AutoSolver) trySemantic(ctx context.Context, page Page, executor ActionExecutor, intent *Intent) (bool, *AttemptEntry) {+ entry := &AttemptEntry{Solver: "semantic"}+ semanticStart := time.Now()++ if as.semantic == nil {+ entry.Status = StatusSkipped+ entry.Error = "semantic engine not configured"+ entry.Duration = time.Since(semanticStart)+ return false, entry+ }++ semanticCtx, cancel := context.WithTimeout(ctx, as.config.SolverTimeout)+ defer cancel()++ initialIntentType := intentTypeOf(intent)+ stepBudget := semanticStepBudget(initialIntentType)+ if stepBudget < 1 {+ stepBudget = 1+ }++ currentIntent := intent+ actionsExecuted := 0++ for step := 0; step < stepBudget; step++ {+ if step > 0 {+ nextIntent, detectErr := as.detectIntent(semanticCtx, page)+ if detectErr != nil {+ slog.Debug("autosolver: semantic step intent refresh failed",+ "step", step+1,+ "error", detectErr)+ } else {+ currentIntent = nextIntent+ }+ }++ if intentTypeOf(currentIntent) == IntentNormal {+ entry.Status = StatusSolved+ entry.Duration = time.Since(semanticStart)+ return true, entry+ }++ suggested, err := as.semantic.SuggestAction(semanticCtx, page, currentIntent)+ if err != nil {+ entry.Status = StatusFailed+ entry.Error = fmt.Sprintf("semantic suggest action: %v", err)+ entry.Duration = time.Since(semanticStart)+ return false, entry+ }++ planned := as.planSemanticAction(currentIntent, step, suggested)+ action, err := as.prepareSemanticAction(semanticCtx, page, currentIntent, step, planned)+ if err != nil {+ slog.Debug("autosolver: semantic action preparation failed",+ "step", step+1,+ "intent", intentTypeOf(currentIntent),+ "error", err)+ entry.Status = StatusFailed+ entry.Error = fmt.Sprintf("prepare semantic action: %v", err)+ entry.Duration = time.Since(semanticStart)+ return false, entry+ }++ if err := executeSuggestedAction(semanticCtx, executor, action); err != nil {+ healedAction, healErr := as.selfHealSemanticAction(semanticCtx, page, currentIntent, step, action)+ if healErr != nil {+ entry.Status = StatusFailed+ entry.Error = fmt.Sprintf("execute semantic action: %v; self-heal failed: %v", err, healErr)+ entry.Duration = time.Since(semanticStart)+ return false, entry+ }++ if err := executeSuggestedAction(semanticCtx, executor, healedAction); err != nil {+ entry.Status = StatusFailed+ entry.Error = fmt.Sprintf("execute semantic self-heal action: %v", err)+ entry.Duration = time.Since(semanticStart)+ return false, entry+ }+ }++ actionsExecuted++++ postIntent, detectErr := as.detectIntent(semanticCtx, page)+ if detectErr != nil {+ slog.Debug("autosolver: semantic post-step intent detection failed",+ "step", step+1,+ "error", detectErr)+ } else {+ currentIntent = postIntent+ if currentIntent.Type == IntentNormal {+ entry.Status = StatusSolved+ entry.Duration = time.Since(semanticStart)+ return true, entry+ }+ }+ }++ if isHighLevelIntent(initialIntentType) && actionsExecuted > 0 {+ entry.Status = StatusSolved+ entry.Duration = time.Since(semanticStart)+ return true, entry+ }++ entry.Status = StatusFailed+ entry.Error = fmt.Sprintf("semantic flow exhausted for intent %q", initialIntentType)+ entry.Duration = time.Since(semanticStart)+ return false, entry+}++type semanticFlowStep struct {+ Query string+ Action ActionType+ EnvKeys []string+}++func (as *AutoSolver) planSemanticAction(intent *Intent, step int, suggested *SuggestedAction) *SuggestedAction {+ planned := &SuggestedAction{Action: ActionNone}+ if suggested != nil {+ copy := *suggested+ planned = ©+ }++ intentType := intentTypeOf(intent)+ flowStep := semanticFlowStepForIntent(intentType, step)++ if planned.Action == ActionNone || isHighLevelIntent(intentType) {+ planned.Action = flowStep.Action+ }++ if planned.Text == "" && planned.Action == ActionType_ {+ planned.Text = firstNonEmptyEnv(flowStep.EnvKeys...)+ }++ if planned.Reason == "" {+ planned.Reason = fmt.Sprintf("semantic flow step %d", step+1)+ }++ return planned+}++func (as *AutoSolver) prepareSemanticAction(ctx context.Context, page Page, intent *Intent, step int, action *SuggestedAction) (*SuggestedAction, error) {+ if action == nil {+ return nil, fmt.Errorf("nil action")+ }++ resolved := *action+ flowStep := semanticFlowStepForIntent(intentTypeOf(intent), step)++ shouldResolveTarget := isHighLevelIntent(intentTypeOf(intent)) || actionNeedsTarget(&resolved)+ if shouldResolveTarget {+ match, err := as.semantic.FindElement(ctx, page, flowStep.Query)+ if err != nil {+ return nil, fmt.Errorf("semantic find element query %q: %w", flowStep.Query, err)+ }+ if match != nil {+ if match.Selector != "" {+ resolved.Selector = match.Selector+ } else if match.Ref != "" {+ resolved.Selector = match.Ref+ }+ if match.X != 0 || match.Y != 0 {+ resolved.X = match.X+ resolved.Y = match.Y+ }+ } else if actionNeedsTarget(&resolved) {+ return nil, fmt.Errorf("semantic find returned no match for query %q", flowStep.Query)+ }+ }++ if resolved.Action == ActionType_ && resolved.Text == "" {+ resolved.Text = firstNonEmptyEnv(flowStep.EnvKeys...)+ if resolved.Text == "" {+ resolved.Action = ActionClick+ }+ }++ if resolved.Action == ActionClick && resolved.Selector == "" && resolved.X == 0 && resolved.Y == 0 {+ return nil, fmt.Errorf("semantic action requires selector or coordinates for query %q", flowStep.Query)+ }++ return &resolved, nil+}++func (as *AutoSolver) selfHealSemanticAction(ctx context.Context, page Page, intent *Intent, step int, original *SuggestedAction) (*SuggestedAction, error) {+ if original == nil {+ return nil, fmt.Errorf("nil action")+ }++ flowStep := semanticFlowStepForIntent(intentTypeOf(intent), step)+ match, err := as.semantic.FindElement(ctx, page, flowStep.Query)+ if err != nil {+ return nil, fmt.Errorf("semantic self-heal find query %q: %w", flowStep.Query, err)+ }+ if match == nil {+ return nil, fmt.Errorf("semantic self-heal returned no match for query %q", flowStep.Query)+ }++ healed := *original+ if match.Selector != "" {+ healed.Selector = match.Selector+ } else if match.Ref != "" {+ healed.Selector = match.Ref+ }+ if match.X != 0 || match.Y != 0 {+ healed.X = match.X+ healed.Y = match.Y+ }++ if healed.Action == ActionType_ && healed.Text == "" {+ healed.Text = firstNonEmptyEnv(flowStep.EnvKeys...)+ if healed.Text == "" {+ healed.Action = ActionClick+ }+ }++ if healed.Action == ActionClick && healed.Selector == "" && healed.X == 0 && healed.Y == 0 {+ return nil, fmt.Errorf("semantic self-heal match for query %q had no actionable selector or coordinates", flowStep.Query)+ }++ return &healed, nil+}++func intentTypeOf(intent *Intent) IntentType {+ if intent == nil {+ return IntentUnknown+ }+ return intent.Type+}++func isHighLevelIntent(intentType IntentType) bool {+ switch intentType {+ case IntentLogin, IntentSignup, IntentForm, IntentOnboarding, IntentNavigation:+ return true+ default:+ return false+ }+}++func semanticStepBudget(intentType IntentType) int {+ switch intentType {+ case IntentLogin:+ return 3+ case IntentSignup:+ return 4+ case IntentForm:+ return 3+ case IntentOnboarding, IntentNavigation:+ return 3+ case IntentCaptcha, IntentBlocked:+ return 2+ default:+ return 1+ }+}++func semanticFlowStepForIntent(intentType IntentType, step int) semanticFlowStep {+ steps := []semanticFlowStep{{Query: "primary continue submit button", Action: ActionClick}}++ switch intentType {+ case IntentCaptcha:+ steps = []semanticFlowStep{+ {Query: "captcha checkbox verify button challenge widget", Action: ActionClick},+ {Query: "verification challenge status text", Action: ActionWait},+ }+ case IntentBlocked:+ steps = []semanticFlowStep{+ {Query: "verify continue button", Action: ActionClick},+ {Query: "body", Action: ActionWait},+ }+ case IntentLogin:+ steps = []semanticFlowStep{+ {Query: "username email input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_LOGIN_USER", "PINCHTAB_AUTOSOLVER_LOGIN_EMAIL"}},+ {Query: "password input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_LOGIN_PASS", "PINCHTAB_AUTOSOLVER_LOGIN_PASSWORD"}},+ {Query: "login submit sign in button", Action: ActionClick},+ }+ case IntentSignup:+ steps = []semanticFlowStep{+ {Query: "name full name input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_SIGNUP_NAME"}},+ {Query: "email input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_SIGNUP_EMAIL"}},+ {Query: "password create password input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_SIGNUP_PASSWORD"}},+ {Query: "sign up register create account submit button", Action: ActionClick},+ }+ case IntentForm:+ steps = []semanticFlowStep{+ {Query: "first required input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_FORM_FIELD1"}},+ {Query: "second required input field", Action: ActionType_, EnvKeys: []string{"PINCHTAB_AUTOSOLVER_FORM_FIELD2", "PINCHTAB_AUTOSOLVER_FORM_EMAIL"}},+ {Query: "primary submit button", Action: ActionClick},+ }+ case IntentOnboarding:+ steps = []semanticFlowStep{+ {Query: "next continue button", Action: ActionClick},+ {Query: "skip button", Action: ActionClick},+ {Query: "done finish submit button", Action: ActionClick},+ }+ case IntentNavigation:+ steps = []semanticFlowStep{+ {Query: "primary navigation link", Action: ActionClick},+ {Query: "continue next button", Action: ActionClick},+ {Query: "submit confirm button", Action: ActionClick},+ }+ }++ if step < 0 {+ step = 0+ }+ if step >= len(steps) {+ step = len(steps) - 1+ }++ return steps[step]+}++func firstNonEmptyEnv(keys ...string) string {+ for _, key := range keys {+ if v := os.Getenv(key); v != "" {+ return v+ }+ }+ return ""+}++func actionNeedsTarget(action *SuggestedAction) bool {+ if action == nil {+ return false+ }++ switch action.Action {+ case ActionClick:+ return action.Selector == "" && action.X == 0 && action.Y == 0+ case ActionType_:+ return action.Selector == "" && action.X == 0 && action.Y == 0+ default:+ return false+ }+}++func executeSuggestedAction(ctx context.Context, executor ActionExecutor, action *SuggestedAction) error {+ if action == nil {+ return fmt.Errorf("nil action")+ }++ switch action.Action {+ case ActionClick:+ if action.Selector != "" {+ x, y, err := resolveSelectorCenter(ctx, executor, action.Selector)+ if err != nil {+ return err+ }+ return executor.Click(ctx, x, y)+ }+ if action.X != 0 || action.Y != 0 {+ return executor.Click(ctx, action.X, action.Y)+ }+ return fmt.Errorf("click action requires selector or coordinates")++ case ActionType_:+ if action.Selector != "" {+ x, y, err := resolveSelectorCenter(ctx, executor, action.Selector)+ if err != nil {+ return err+ }+ if err := executor.Click(ctx, x, y); err != nil {+ return err+ }+ } else if action.X != 0 || action.Y != 0 {+ if err := executor.Click(ctx, action.X, action.Y); err != nil {+ return err+ }+ }+ return executor.Type(ctx, action.Text)++ case ActionNavigate:+ return executor.Navigate(ctx, action.URL)++ case ActionWait:+ selector := action.Selector+ if selector == "" {+ selector = "body"+ }+ return executor.WaitFor(ctx, selector, 5*time.Second)++ case ActionEvaluate:+ if action.Expr == "" {+ return fmt.Errorf("evaluate action requires expr")+ }+ var out interface{}+ return executor.Evaluate(ctx, action.Expr, &out)++ case ActionNone:+ return nil++ default:+ return fmt.Errorf("unsupported action: %s", action.Action)+ }+}++func resolveSelectorCenter(ctx context.Context, executor ActionExecutor, selector string) (float64, float64, error) {+ var coords struct {+ X float64 `json:"x"`+ Y float64 `json:"y"`+ }++ expr := fmt.Sprintf(`(() => {+ const el = document.querySelector(%q);+ if (!el) return null;+ const r = el.getBoundingClientRect();+ return {x: r.x + r.width/2, y: r.y + r.height/2};+ })()`, selector)++ if err := executor.Evaluate(ctx, expr, &coords); err != nil {+ return 0, 0, fmt.Errorf("resolve selector %q: %w", selector, err)+ }++ return coords.X, coords.Y, nil+}+// tryLLM builds a trimmed request and asks the LLM for the next action.func (as *AutoSolver) tryLLM(ctx context.Context, page Page, executor ActionExecutor, history []AttemptEntry) (bool, *AttemptEntry) {llmStart := time.Now()@@ -291,21 +772,11 @@ func executeAction(ctx context.Context, executor ActionExecutor, resp *LLMResponswitch resp.Action {case ActionClick:if resp.Selector != "" {- // Resolve selector to coordinates via evaluate.- var coords struct {- X float64 `json:"x"`- Y float64 `json:"y"`- }- expr := fmt.Sprintf(`(() => {- const el = document.querySelector(%q);- if (!el) return null;- const r = el.getBoundingClientRect();- return {x: r.x + r.width/2, y: r.y + r.height/2};- })()`, resp.Selector)- if err := executor.Evaluate(ctx, expr, &coords); err != nil {- return fmt.Errorf("resolve selector %q: %w", resp.Selector, err)+ x, y, err := resolveSelectorCenter(ctx, executor, resp.Selector)+ if err != nil {+ return err}- return executor.Click(ctx, coords.X, coords.Y)+ return executor.Click(ctx, x, y)}return fmt.Errorf("click action requires selector")diff --git a/internal/autosolver/autosolver_test.go b/internal/autosolver/autosolver_test.goindex 66fc7874..66573149 100644--- a/internal/autosolver/autosolver_test.go+++ b/internal/autosolver/autosolver_test.go@@ -24,6 +24,9 @@ type mockExecutor struct {clickCalled inttypeCalled intnavigateCalled int+ evaluateCalled int+ waitCalled int+ evaluateErr error}func (m *mockExecutor) Click(_ context.Context, _, _ float64) error {@@ -34,19 +37,26 @@ func (m *mockExecutor) Type(_ context.Context, _ string) error {m.typeCalled++return nil}-func (m *mockExecutor) WaitFor(_ context.Context, _ string, _ time.Duration) error { return nil }-func (m *mockExecutor) Evaluate(_ context.Context, _ string, _ interface{}) error { return nil }+func (m *mockExecutor) WaitFor(_ context.Context, _ string, _ time.Duration) error {+ m.waitCalled+++ return nil+}+func (m *mockExecutor) Evaluate(_ context.Context, _ string, _ interface{}) error {+ m.evaluateCalled+++ return m.evaluateErr+}func (m *mockExecutor) Navigate(_ context.Context, _ string) error {m.navigateCalled++return nil}type mockSolver struct {- name string- priority int- canHandle bool- solved bool- err error+ name string+ priority int+ canHandle bool+ solved bool+ err error+ solveCalls int}func (m *mockSolver) Name() string { return m.name }@@ -55,6 +65,7 @@ func (m *mockSolver) CanHandle(_ context.Context, _ Page) (bool, error) {return m.canHandle, nil}func (m *mockSolver) Solve(_ context.Context, _ Page, _ ActionExecutor) (*Result, error) {+ m.solveCalls++if m.err != nil {return &Result{Error: m.err.Error()}, m.err}@@ -62,18 +73,55 @@ func (m *mockSolver) Solve(_ context.Context, _ Page, _ ActionExecutor) (*Result}type mockSemantic struct {- intent *Intent- err error+ intent *Intent+ err error+ detectSeq []*Intent+ detectCalls int+ findMatch *ElementMatch+ findSeq []*ElementMatch+ findErr error+ action *SuggestedAction+ actionSeq []*SuggestedAction+ actionErr error+ findCalls int+ findQueries []string+ suggestCalls int}func (m *mockSemantic) DetectIntent(_ context.Context, _ Page) (*Intent, error) {+ if len(m.detectSeq) > 0 {+ idx := m.detectCalls+ if idx >= len(m.detectSeq) {+ idx = len(m.detectSeq) - 1+ }+ m.detectCalls+++ return m.detectSeq[idx], m.err+ }+ m.detectCalls++return m.intent, m.err}-func (m *mockSemantic) FindElement(_ context.Context, _ Page, _ string) (*ElementMatch, error) {- return nil, nil+func (m *mockSemantic) FindElement(_ context.Context, _ Page, query string) (*ElementMatch, error) {+ m.findCalls+++ m.findQueries = append(m.findQueries, query)+ if len(m.findSeq) > 0 {+ idx := m.findCalls - 1+ if idx >= len(m.findSeq) {+ idx = len(m.findSeq) - 1+ }+ return m.findSeq[idx], m.findErr+ }+ return m.findMatch, m.findErr}func (m *mockSemantic) SuggestAction(_ context.Context, _ Page, _ *Intent) (*SuggestedAction, error) {- return nil, nil+ m.suggestCalls+++ if len(m.actionSeq) > 0 {+ idx := m.suggestCalls - 1+ if idx >= len(m.actionSeq) {+ idx = len(m.actionSeq) - 1+ }+ return m.actionSeq[idx], m.actionErr+ }+ return m.action, m.actionErr}type mockLLM struct {@@ -147,6 +195,245 @@ func TestSolve_SemanticDetection(t *testing.T) {}}+func TestSolve_SemanticFirst_SuccessSkipsRuleSolvers(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1++ semantic := &mockSemantic{+ detectSeq: []*Intent{+ {Type: IntentCaptcha, Confidence: 0.9},+ {Type: IntentNormal, Confidence: 0.9},+ },+ action: &SuggestedAction{+ Action: ActionClick,+ Selector: "#verify-button",+ },+ }++ solver := &mockSolver{+ name: "rule-solver",+ priority: 10,+ canHandle: true,+ solved: true,+ }++ as := New(cfg, semantic, nil)+ as.Registry().MustRegister(solver)++ page := &mockPage{title: "Challenge Page", url: "https://example.com"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Error("expected Solved=true")+ }+ if result.SolverUsed != "semantic" {+ t.Errorf("expected solver 'semantic', got %q", result.SolverUsed)+ }+ if solver.solveCalls != 0 {+ t.Errorf("expected rule solver not to run, got %d calls", solver.solveCalls)+ }+ if semantic.suggestCalls == 0 {+ t.Error("expected semantic SuggestAction to be called")+ }+}++func TestSolve_SemanticFirst_FailureFallsBackToRuleSolvers(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1++ semantic := &mockSemantic{+ detectSeq: []*Intent{+ {Type: IntentCaptcha, Confidence: 0.9},+ {Type: IntentCaptcha, Confidence: 0.8},+ },+ action: &SuggestedAction{+ Action: ActionClick,+ Selector: "#verify-button",+ },+ }++ solver := &mockSolver{+ name: "rule-solver",+ priority: 10,+ canHandle: true,+ solved: true,+ }++ as := New(cfg, semantic, nil)+ as.Registry().MustRegister(solver)++ page := &mockPage{title: "Challenge Page", url: "https://example.com"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Error("expected Solved=true via rule solver fallback")+ }+ if result.SolverUsed != "rule-solver" {+ t.Errorf("expected solver 'rule-solver', got %q", result.SolverUsed)+ }+ if solver.solveCalls == 0 {+ t.Error("expected rule solver to run after semantic failure")+ }+ if len(result.History) == 0 {+ t.Fatal("expected non-empty attempt history")+ }+ if result.History[0].Solver != "semantic" {+ t.Errorf("expected first attempt to be semantic, got %q", result.History[0].Solver)+ }+ if result.History[0].Status != StatusFailed {+ t.Errorf("expected semantic attempt to fail before fallback, got %q", result.History[0].Status)+ }+}++func TestSolve_SemanticHighLevel_LoginFlow(t *testing.T) {+ t.Setenv("PINCHTAB_AUTOSOLVER_LOGIN_USER", "[email protected]")+ t.Setenv("PINCHTAB_AUTOSOLVER_LOGIN_PASSWORD", "secret")++ cfg := DefaultConfig()+ cfg.MaxAttempts = 1++ semantic := &mockSemantic{+ detectSeq: []*Intent{+ {Type: IntentLogin, Confidence: 0.9},+ {Type: IntentLogin, Confidence: 0.9},+ {Type: IntentLogin, Confidence: 0.9},+ {Type: IntentLogin, Confidence: 0.9},+ },+ findMatch: &ElementMatch{Selector: "#login-field"},+ }++ solver := &mockSolver{+ name: "rule-solver",+ priority: 10,+ canHandle: true,+ solved: true,+ }++ as := New(cfg, semantic, nil)+ as.Registry().MustRegister(solver)++ page := &mockPage{title: "Sign in", url: "https://example.com/login"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Error("expected Solved=true")+ }+ if result.SolverUsed != "semantic" {+ t.Errorf("expected solver 'semantic', got %q", result.SolverUsed)+ }+ if solver.solveCalls != 0 {+ t.Errorf("expected rule solver not to run, got %d calls", solver.solveCalls)+ }+ if semantic.findCalls < 3 {+ t.Errorf("expected semantic /find to run on multiple flow steps, got %d calls", semantic.findCalls)+ }+ if executor.typeCalled < 2 {+ t.Errorf("expected form-filling type actions, got %d", executor.typeCalled)+ }+}++func TestSolve_SemanticHighLevel_LoginFallbackWhenFindFails(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1++ semantic := &mockSemantic{+ detectSeq: []*Intent{{Type: IntentLogin, Confidence: 0.9}},+ findMatch: nil,+ }++ solver := &mockSolver{+ name: "rule-solver",+ priority: 10,+ canHandle: true,+ solved: true,+ }++ as := New(cfg, semantic, nil)+ as.Registry().MustRegister(solver)++ page := &mockPage{title: "Sign in", url: "https://example.com/login"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Error("expected Solved=true via rule solver fallback")+ }+ if result.SolverUsed != "rule-solver" {+ t.Errorf("expected solver 'rule-solver', got %q", result.SolverUsed)+ }+ if semantic.findCalls == 0 {+ t.Error("expected semantic /find attempt before fallback")+ }+ if len(result.History) == 0 {+ t.Fatal("expected non-empty attempt history")+ }+ if result.History[0].Solver != "semantic" {+ t.Errorf("expected first history entry to be semantic, got %q", result.History[0].Solver)+ }+}++func TestSolve_SemanticSelfHealFailureFallsBackToRuleSolvers(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1++ semantic := &mockSemantic{+ detectSeq: []*Intent{{Type: IntentCaptcha, Confidence: 0.9}},+ action: &SuggestedAction{+ Action: ActionClick,+ Selector: "#verify",+ },+ findMatch: &ElementMatch{Selector: "#verify"},+ }++ solver := &mockSolver{+ name: "rule-solver",+ priority: 10,+ canHandle: true,+ solved: true,+ }++ as := New(cfg, semantic, nil)+ as.Registry().MustRegister(solver)++ page := &mockPage{title: "Challenge Page", url: "https://example.com"}+ executor := &mockExecutor{evaluateErr: fmt.Errorf("selector lookup failed")}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Error("expected solve success via rule solver fallback")+ }+ if result.SolverUsed != "rule-solver" {+ t.Errorf("expected solver 'rule-solver', got %q", result.SolverUsed)+ }+ if len(result.History) == 0 || result.History[0].Solver != "semantic" {+ t.Fatalf("expected semantic attempt in history, got %+v", result.History)+ }+ if result.History[0].Status != StatusFailed {+ t.Fatalf("expected semantic attempt to fail, got %q", result.History[0].Status)+ }+ if solver.solveCalls == 0 {+ t.Fatal("expected rule solver to run after semantic self-heal failure")+ }+}+func TestSolve_FallbackChain(t *testing.T) {cfg := DefaultConfig()cfg.MaxAttempts = 1@@ -328,11 +615,94 @@ func TestSolve_PriorityOrdering(t *testing.T) {}}+func TestSolve_UsesConfiguredSolverOrder(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1+ cfg.RetryBaseDelay = time.Millisecond+ cfg.Solvers = []string{"third", "first", "second"}++ var solveOrder []string+ makeSolver := func(name string, priority int, solved bool) Solver {+ return &trackingSolver{+ name: name,+ priority: priority,+ canHandle: true,+ solved: solved,+ order: &solveOrder,+ }+ }++ as := New(cfg, nil, nil)+ as.Registry().MustRegister(makeSolver("first", 10, false))+ as.Registry().MustRegister(makeSolver("second", 20, false))+ as.Registry().MustRegister(makeSolver("third", 30, true))++ page := &mockPage{title: "Just a moment...", url: "https://example.com"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Fatal("expected solve success from configured first solver")+ }+ if result.SolverUsed != "third" {+ t.Fatalf("expected solver 'third', got %q", result.SolverUsed)+ }+ if len(solveOrder) != 1 {+ t.Fatalf("expected exactly one solver call, got %d (%v)", len(solveOrder), solveOrder)+ }+ if solveOrder[0] != "third" {+ t.Fatalf("expected configured solver order to try 'third' first, got %q", solveOrder[0])+ }+}++func TestSolve_ConfiguredSolverOrderFallbackWhenNoConfiguredNamesMatch(t *testing.T) {+ cfg := DefaultConfig()+ cfg.MaxAttempts = 1+ cfg.RetryBaseDelay = time.Millisecond+ cfg.Solvers = []string{"missing-one", "missing-two"}++ var solveOrder []string+ makeSolver := func(name string, priority int, solved bool) Solver {+ return &trackingSolver{+ name: name,+ priority: priority,+ canHandle: true,+ solved: solved,+ order: &solveOrder,+ }+ }++ as := New(cfg, nil, nil)+ as.Registry().MustRegister(makeSolver("first", 10, true))+ as.Registry().MustRegister(makeSolver("second", 20, false))++ page := &mockPage{title: "Just a moment...", url: "https://example.com"}+ executor := &mockExecutor{}++ result, err := as.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("unexpected error: %v", err)+ }+ if !result.Solved {+ t.Fatal("expected solve success from priority-order fallback")+ }+ if len(solveOrder) != 1 {+ t.Fatalf("expected one solver attempt, got %d (%v)", len(solveOrder), solveOrder)+ }+ if solveOrder[0] != "first" {+ t.Fatalf("expected fallback to priority order starting with 'first', got %q", solveOrder[0])+ }+}+// trackingSolver records the order in which Solve is called.type trackingSolver struct {name stringpriority intcanHandle bool+ solved boolorder *[]string}@@ -343,5 +713,5 @@ func (s *trackingSolver) CanHandle(_ context.Context, _ Page) (bool, error) {}func (s *trackingSolver) Solve(_ context.Context, _ Page, _ ActionExecutor) (*Result, error) {*s.order = append(*s.order, s.name)- return &Result{Solved: false}, nil+ return &Result{Solved: s.solved}, nil}diff --git a/internal/autosolver/challenge_detection.go b/internal/autosolver/challenge_detection.gonew file mode 100644index 00000000..ffbd6aac--- /dev/null+++ b/internal/autosolver/challenge_detection.go@@ -0,0 +1,165 @@+package autosolver++import "strings"++// DetectChallengeIntent classifies known challenge pages using title, URL,+// and HTML markers. It returns nil when no challenge signal is found.+func DetectChallengeIntent(title, url, html string) *Intent {+ lowerTitle := strings.ToLower(title)+ lowerURL := strings.ToLower(url)+ lowerHTML := strings.ToLower(html)+ v3 := isRecaptchaV3Challenge(lowerURL, lowerHTML)++ if isTurnstileChallenge(lowerTitle, lowerURL, lowerHTML) {+ return &Intent{+ Type: IntentCaptcha,+ Confidence: 0.95,+ ChallengeType: "turnstile",+ Details: "cloudflare turnstile challenge detected",+ }+ }++ if v3 {+ return &Intent{+ Type: IntentCaptcha,+ Confidence: 0.9,+ ChallengeType: "recaptcha-v3",+ Details: "reCAPTCHA v3 challenge detected",+ }+ }++ if !v3 && isRecaptchaV2Challenge(lowerURL, lowerHTML) {+ return &Intent{+ Type: IntentCaptcha,+ Confidence: 0.9,+ ChallengeType: "recaptcha-v2",+ Details: "reCAPTCHA v2 challenge detected",+ }+ }++ if isHCaptchaChallenge(lowerURL, lowerHTML) {+ return &Intent{+ Type: IntentCaptcha,+ Confidence: 0.9,+ ChallengeType: "hcaptcha",+ Details: "hCaptcha challenge detected",+ }+ }++ if isCustomJSChallenge(lowerTitle, lowerURL, lowerHTML) {+ return &Intent{+ Type: IntentBlocked,+ Confidence: 0.85,+ ChallengeType: "custom-js",+ Details: "custom JavaScript anti-bot challenge detected",+ }+ }++ if containsAny(lowerTitle, "captcha", "verify you are human", "i am not a robot") ||+ containsAny(lowerURL, "captcha", "recaptcha", "hcaptcha", "turnstile") ||+ containsAny(lowerHTML, "captcha", "verify you are human", "i am not a robot") {+ return &Intent{+ Type: IntentCaptcha,+ Confidence: 0.7,+ ChallengeType: "captcha-generic",+ Details: "generic captcha challenge detected",+ }+ }++ return nil+}++func isTurnstileChallenge(title, url, html string) bool {+ return containsAny(title,+ "just a moment",+ "attention required",+ "checking your browser",+ ) || containsAny(url,+ "cdn-cgi/challenge-platform",+ "/cdn-cgi/challenge",+ ) || containsAny(html,+ "challenges.cloudflare.com/turnstile",+ "cf-turnstile",+ "turnstile.render(",+ )+}++func isRecaptchaV3Challenge(url, html string) bool {+ return containsAny(html,+ "grecaptcha.execute(",+ "grecaptcha.enterprise.execute(",+ "recaptcha/api.js?render=",+ "recaptcha/enterprise.js?render=",+ )+}++func isRecaptchaV2Challenge(url, html string) bool {+ return containsAny(url,+ "recaptcha",+ "google.com/recaptcha",+ ) || containsAny(html,+ "g-recaptcha",+ "recaptcha-checkbox",+ "api2/anchor",+ "google.com/recaptcha/api.js",+ )+}++func isHCaptchaChallenge(url, html string) bool {+ return containsAny(url,+ "hcaptcha",+ ) || containsAny(html,+ "hcaptcha.com/1/api.js",+ "h-captcha",+ "hcaptcha",+ )+}++func isCustomJSChallenge(title, url, html string) bool {+ titleSignal := containsAny(title,+ "please enable javascript",+ "browser integrity check",+ "access denied",+ "forbidden",+ "blocked",+ )+ urlSignal := containsAny(url,+ "challenge",+ "bot",+ "verify",+ )+ htmlSignal := containsAny(html,+ "__cf_chl",+ "window._cf_chl_opt",+ "challenge-form",+ "jschl",+ "bot challenge",+ "anti-bot",+ "anti bot",+ "please enable javascript",+ "checking your browser before accessing",+ "browser integrity check",+ "navigator.webdriver",+ )++ // Primary signal comes from HTML markers.+ if htmlSignal {+ return true+ }++ // Fallback when HTML cannot be read.+ if html == "" && titleSignal && urlSignal {+ return true+ }++ return false+}++func containsAny(haystack string, needles ...string) bool {+ for _, needle := range needles {+ if strings.Contains(haystack, needle) {+ return true+ }+ }+ return false+}diff --git a/internal/autosolver/challenge_detection_test.go b/internal/autosolver/challenge_detection_test.gonew file mode 100644index 00000000..c13959d9--- /dev/null+++ b/internal/autosolver/challenge_detection_test.go@@ -0,0 +1,93 @@+package autosolver++import "testing"++func TestDetectChallengeIntent_Turnstile(t *testing.T) {+ intent := DetectChallengeIntent(+ "Just a moment...",+ "https://example.com/cdn-cgi/challenge-platform/h/b/orchestrate/chl_page/v1",+ `<script src="https://challenges.cloudflare.com/turnstile/v0/api.js"></script>`,+ )+ if intent == nil {+ t.Fatal("expected challenge intent")+ }+ if intent.Type != IntentCaptcha {+ t.Fatalf("expected captcha intent, got %q", intent.Type)+ }+ if intent.ChallengeType != "turnstile" {+ t.Fatalf("expected turnstile challenge type, got %q", intent.ChallengeType)+ }+}++func TestDetectChallengeIntent_RecaptchaV2(t *testing.T) {+ intent := DetectChallengeIntent(+ "Verify",+ "https://example.com/login",+ `<div class="g-recaptcha" data-sitekey="abc"></div>+ <script src="https://www.google.com/recaptcha/api.js"></script>`,+ )+ if intent == nil {+ t.Fatal("expected challenge intent")+ }+ if intent.ChallengeType != "recaptcha-v2" {+ t.Fatalf("expected recaptcha-v2 challenge type, got %q", intent.ChallengeType)+ }+}++func TestDetectChallengeIntent_RecaptchaV3(t *testing.T) {+ intent := DetectChallengeIntent(+ "Welcome",+ "https://example.com/secure",+ `<script src="https://www.google.com/recaptcha/api.js?render=site_key"></script>+ <script>grecaptcha.execute('site_key', {action: 'login'})</script>`,+ )+ if intent == nil {+ t.Fatal("expected challenge intent")+ }+ if intent.ChallengeType != "recaptcha-v3" {+ t.Fatalf("expected recaptcha-v3 challenge type, got %q", intent.ChallengeType)+ }+}++func TestDetectChallengeIntent_HCaptcha(t *testing.T) {+ intent := DetectChallengeIntent(+ "Verify",+ "https://example.com/verify",+ `<div class="h-captcha" data-sitekey="abc"></div>+ <script src="https://hcaptcha.com/1/api.js" async defer></script>`,+ )+ if intent == nil {+ t.Fatal("expected challenge intent")+ }+ if intent.ChallengeType != "hcaptcha" {+ t.Fatalf("expected hcaptcha challenge type, got %q", intent.ChallengeType)+ }+}++func TestDetectChallengeIntent_CustomJS(t *testing.T) {+ intent := DetectChallengeIntent(+ "Browser Integrity Check",+ "https://example.com/challenge",+ `<html><body><script>window._cf_chl_opt = {};</script><div>Please enable JavaScript</div></body></html>`,+ )+ if intent == nil {+ t.Fatal("expected challenge intent")+ }+ if intent.ChallengeType != "custom-js" {+ t.Fatalf("expected custom-js challenge type, got %q", intent.ChallengeType)+ }+ if intent.Type != IntentBlocked {+ t.Fatalf("expected blocked intent for custom-js, got %q", intent.Type)+ }+}++func TestDetectChallengeIntent_None(t *testing.T) {+ intent := DetectChallengeIntent(+ "Example Domain",+ "https://example.com",+ `<html><body><h1>Example Domain</h1></body></html>`,+ )+ if intent != nil {+ t.Fatalf("expected nil intent, got %+v", intent)+ }+}diff --git a/internal/autosolver/heuristics.go b/internal/autosolver/heuristics.goindex f53447d5..b0dcf06a 100644--- a/internal/autosolver/heuristics.go+++ b/internal/autosolver/heuristics.go@@ -7,6 +7,9 @@ import "strings"// well-known page-title patterns to classify the page.func detectIntentByTitle(title string) *Intent {lower := strings.ToLower(title)+ if challenge := DetectChallengeIntent(title, "", ""); challenge != nil {+ return challenge+ }// Cloudflare challenge patternscfPatterns := []string{"just a moment", "attention required", "checking your browser"}@@ -57,6 +60,42 @@ func detectIntentByTitle(title string) *Intent {}}+ // Onboarding patterns+ onboardingPatterns := []string{"getting started", "welcome", "onboarding", "complete your profile", "step 1"}+ for _, p := range onboardingPatterns {+ if strings.Contains(lower, p) {+ return &Intent{+ Type: IntentOnboarding,+ Confidence: 0.65,+ Details: "onboarding flow detected via title",+ }+ }+ }++ // Navigation/task-flow patterns+ navigationPatterns := []string{"continue", "next step", "choose option", "select plan", "wizard"}+ for _, p := range navigationPatterns {+ if strings.Contains(lower, p) {+ return &Intent{+ Type: IntentNavigation,+ Confidence: 0.6,+ Details: "navigation flow detected via title",+ }+ }+ }++ // Generic form-filling patterns+ formPatterns := []string{"application form", "contact form", "checkout", "survey", "questionnaire"}+ for _, p := range formPatterns {+ if strings.Contains(lower, p) {+ return &Intent{+ Type: IntentForm,+ Confidence: 0.6,+ Details: "form flow detected via title",+ }+ }+ }+// Blocked/access-denied patternsblockedPatterns := []string{"access denied", "forbidden", "blocked", "unauthorized"}for _, p := range blockedPatterns {diff --git a/internal/autosolver/semantic/adapter.go b/internal/autosolver/semantic/adapter.goindex e4340ee8..5f6714a1 100644--- a/internal/autosolver/semantic/adapter.go+++ b/internal/autosolver/semantic/adapter.go@@ -29,6 +29,10 @@ func NewAdapter(m semantic.ElementMatcher) *Adapter {func (a *Adapter) DetectIntent(ctx context.Context, page autosolver.Page) (*autosolver.Intent, error) {title := strings.ToLower(page.Title())url := page.URL()+ html, _ := page.HTML()+ if challenge := autosolver.DetectChallengeIntent(title, url, html); challenge != nil {+ return challenge, nil+ }// Cloudflare challenge indicatorscfIndicators := []string{"just a moment", "attention required", "checking your browser"}@@ -86,6 +90,39 @@ func (a *Adapter) DetectIntent(ctx context.Context, page autosolver.Page) (*auto}}+ onboardingPatterns := []string{"getting started", "welcome", "onboarding", "complete your profile", "step 1"}+ for _, p := range onboardingPatterns {+ if strings.Contains(title, p) {+ return &autosolver.Intent{+ Type: autosolver.IntentOnboarding,+ Confidence: 0.65,+ Details: "onboarding flow detected via semantic title analysis",+ }, nil+ }+ }++ navigationPatterns := []string{"continue", "next step", "choose option", "select plan", "wizard"}+ for _, p := range navigationPatterns {+ if strings.Contains(title, p) {+ return &autosolver.Intent{+ Type: autosolver.IntentNavigation,+ Confidence: 0.6,+ Details: "navigation flow detected via semantic title analysis",+ }, nil+ }+ }++ formPatterns := []string{"application form", "contact form", "checkout", "survey", "questionnaire"}+ for _, p := range formPatterns {+ if strings.Contains(title, p) {+ return &autosolver.Intent{+ Type: autosolver.IntentForm,+ Confidence: 0.6,+ Details: "form flow detected via semantic title analysis",+ }, nil+ }+ }+return &autosolver.Intent{Type: autosolver.IntentNormal,Confidence: 0.6,@@ -127,8 +164,11 @@ func (a *Adapter) FindElement(ctx context.Context, page autosolver.Page, query s}best := result.Matches[0]+ // Semantic refs are selector-compatible in this adapter, so keep both+ // fields aligned for executors that prefer CSS selectors.return &autosolver.ElementMatch{Ref: best.Ref,+ Selector: best.Ref,Role: best.Role,Name: best.Name,Score: best.Score,@@ -153,6 +193,12 @@ func (a *Adapter) SuggestAction(ctx context.Context, page autosolver.Page, intenreturn a.suggestLoginAction(ctx, page)case autosolver.IntentSignup:return a.suggestSignupAction(ctx, page)+ case autosolver.IntentOnboarding:+ return a.suggestOnboardingAction(ctx, page)+ case autosolver.IntentNavigation:+ return a.suggestNavigationAction(ctx, page)+ case autosolver.IntentForm:+ return a.suggestFormAction(ctx, page)case autosolver.IntentBlocked:return &autosolver.SuggestedAction{Action: autosolver.ActionWait,@@ -219,6 +265,54 @@ func (a *Adapter) suggestSignupAction(ctx context.Context, page autosolver.Page)}, nil}+func (a *Adapter) suggestOnboardingAction(ctx context.Context, page autosolver.Page) (*autosolver.SuggestedAction, error) {+ match, err := a.FindElement(ctx, page, "next continue skip done button")+ if err != nil || match == nil {+ return &autosolver.SuggestedAction{+ Action: autosolver.ActionWait,+ Reason: "onboarding controls not found yet",+ }, nil+ }++ return &autosolver.SuggestedAction{+ Action: autosolver.ActionClick,+ Selector: match.Selector,+ Reason: "advancing onboarding flow",+ }, nil+}++func (a *Adapter) suggestNavigationAction(ctx context.Context, page autosolver.Page) (*autosolver.SuggestedAction, error) {+ match, err := a.FindElement(ctx, page, "primary navigation button next continue link")+ if err != nil || match == nil {+ return &autosolver.SuggestedAction{+ Action: autosolver.ActionNone,+ Reason: "navigation controls not found",+ }, nil+ }++ return &autosolver.SuggestedAction{+ Action: autosolver.ActionClick,+ Selector: match.Selector,+ Reason: "advancing navigation flow",+ }, nil+}++func (a *Adapter) suggestFormAction(ctx context.Context, page autosolver.Page) (*autosolver.SuggestedAction, error) {+ match, err := a.FindElement(ctx, page, "required input field form control")+ if err != nil || match == nil {+ return &autosolver.SuggestedAction{+ Action: autosolver.ActionNone,+ Reason: "form fields not found",+ }, nil+ }++ return &autosolver.SuggestedAction{+ Action: autosolver.ActionClick,+ Selector: match.Selector,+ Reason: "focusing a required form field",+ }, nil+}+// detectViaSemanticMatch uses the semantic matcher to classify page// elements and infer the page intent.func (a *Adapter) detectViaSemanticMatch(ctx context.Context, page autosolver.Page) (*autosolver.Intent, error) {@@ -242,6 +336,33 @@ func (a *Adapter) detectViaSemanticMatch(ctx context.Context, page autosolver.Pa}, nil}+ match, err = a.FindElement(ctx, page, "next continue done button")+ if err == nil && match != nil && match.Score > 0.6 {+ return &autosolver.Intent{+ Type: autosolver.IntentOnboarding,+ Confidence: match.Score,+ Details: "onboarding flow detected via semantic element matching",+ }, nil+ }++ match, err = a.FindElement(ctx, page, "primary navigation button link")+ if err == nil && match != nil && match.Score > 0.6 {+ return &autosolver.Intent{+ Type: autosolver.IntentNavigation,+ Confidence: match.Score,+ Details: "navigation flow detected via semantic element matching",+ }, nil+ }++ match, err = a.FindElement(ctx, page, "required input field submit button")+ if err == nil && match != nil && match.Score > 0.6 {+ return &autosolver.Intent{+ Type: autosolver.IntentForm,+ Confidence: match.Score,+ Details: "form flow detected via semantic element matching",+ }, nil+ }+return nil, nil}@@ -254,14 +375,15 @@ func extractDescriptors(html string) []semantic.ElementDescriptor {// Extract interactive elements by scanning for common patterns.// A full implementation would use the a11y tree from the bridge.patterns := []struct {- tag string- role string+ searchTag string+ selTag string+ role string}{- {"<input", "textbox"},- {"<button", "button"},- {"<a ", "link"},- {"<select", "combobox"},- {"<textarea", "textbox"},+ {"<input", "input", "textbox"},+ {"<button", "button", "button"},+ {"<a ", "a", "link"},+ {"<select", "select", "combobox"},+ {"<textarea", "textarea", "textbox"},}lower := strings.ToLower(html)@@ -269,11 +391,11 @@ func extractDescriptors(html string) []semantic.ElementDescriptor {for _, p := range patterns {idx := 0for {- pos := strings.Index(lower[idx:], p.tag)+ pos := strings.Index(lower[idx:], p.searchTag)if pos == -1 {break}- idx += pos + len(p.tag)+ idx += pos + len(p.searchTag)// Extract a rough name from surrounding text.end := strings.Index(lower[idx:], ">")@@ -281,6 +403,8 @@ func extractDescriptors(html string) []semantic.ElementDescriptor {break}snippet := html[idx : idx+end]+ selector := buildSelector(p.selTag, snippet)+name := extractAttr(snippet, "placeholder")if name == "" {name = extractAttr(snippet, "aria-label")@@ -288,10 +412,13 @@ func extractDescriptors(html string) []semantic.ElementDescriptor {if name == "" {name = extractAttr(snippet, "name")}+ if name == "" {+ name = selector+ }ref++descs = append(descs, semantic.ElementDescriptor{- Ref: fmt.Sprintf("e%d", ref),+ Ref: selector,Role: p.role,Name: name,})@@ -304,6 +431,36 @@ func extractDescriptors(html string) []semantic.ElementDescriptor {return descs}+func buildSelector(tag, snippet string) string {+ id := extractAttr(snippet, "id")+ if id != "" {+ return fmt.Sprintf("#%s", id)+ }++ name := extractAttr(snippet, "name")+ if name != "" {+ return fmt.Sprintf(`%s[name="%s"]`, tag, escapeAttrValue(name))+ }++ placeholder := extractAttr(snippet, "placeholder")+ if placeholder != "" {+ return fmt.Sprintf(`%s[placeholder="%s"]`, tag, escapeAttrValue(placeholder))+ }++ aria := extractAttr(snippet, "aria-label")+ if aria != "" {+ return fmt.Sprintf(`%s[aria-label="%s"]`, tag, escapeAttrValue(aria))+ }++ return tag+}++func escapeAttrValue(v string) string {+ v = strings.ReplaceAll(v, `\\`, `\\\\`)+ v = strings.ReplaceAll(v, `"`, `\\"`)+ return v+}+// extractAttr extracts an HTML attribute value from a tag snippet.func extractAttr(snippet, attr string) string {lower := strings.ToLower(snippet)diff --git a/internal/autosolver/solvers/jschallenge.go b/internal/autosolver/solvers/jschallenge.gonew file mode 100644index 00000000..dda6fbfb--- /dev/null+++ b/internal/autosolver/solvers/jschallenge.go@@ -0,0 +1,111 @@+package solvers++import (+ "context"+ "fmt"+ "time"++ "github.com/pinchtab/pinchtab/internal/autosolver"+)++// JSChallenge is a built-in fallback solver for generic JavaScript-based+// anti-bot blocks and interstitial challenge pages.+type JSChallenge struct{}++func (s *JSChallenge) Name() string { return "jschallenge" }+func (s *JSChallenge) Priority() int { return 40 }++func (s *JSChallenge) CanHandle(_ context.Context, page autosolver.Page) (bool, error) {+ html, err := page.HTML()+ if err != nil {+ return false, nil+ }+ intent := autosolver.DetectChallengeIntent(page.Title(), page.URL(), html)+ if intent == nil {+ return false, nil+ }+ return intent.ChallengeType == "custom-js" || intent.Type == autosolver.IntentBlocked, nil+}++func (s *JSChallenge) Solve(ctx context.Context, page autosolver.Page, executor autosolver.ActionExecutor) (*autosolver.Result, error) {+ result := &autosolver.Result{SolverUsed: s.Name()}++ // Step 1: wait briefly for JS anti-bot scripts to execute naturally.+ if err := executor.WaitFor(ctx, "body", 2*time.Second); err != nil {+ result.Error = fmt.Sprintf("wait for body: %v", err)+ return result, err+ }++ // Step 2: click common continue/verify buttons if present.+ for _, selector := range []string{+ "button[type='submit']",+ "button[name='verify']",+ "button[id*='verify']",+ "button[class*='verify']",+ "input[type='submit']",+ "#challenge-stage button",+ "form button",+ } {+ // Non-fatal; continue probing other controls.+ _ = clickIfExists(ctx, executor, selector)+ }++ // Step 3: poll for resolution by challenge intent re-check.+ deadline := time.Now().Add(8 * time.Second)+ for time.Now().Before(deadline) {+ html, err := page.HTML()+ if err == nil {+ intent := autosolver.DetectChallengeIntent(page.Title(), page.URL(), html)+ if intent == nil || intent.Type == autosolver.IntentNormal {+ result.Solved = true+ result.FinalTitle = page.Title()+ result.FinalURL = page.URL()+ return result, nil+ }+ }++ select {+ case <-ctx.Done():+ result.Error = ctx.Err().Error()+ return result, ctx.Err()+ case <-time.After(400 * time.Millisecond):+ }+ }++ // Final state snapshot.+ result.FinalTitle = page.Title()+ result.FinalURL = page.URL()+ html, err := page.HTML()+ if err != nil {+ result.Error = fmt.Sprintf("get final html: %v", err)+ return result, nil+ }+ intent := autosolver.DetectChallengeIntent(page.Title(), page.URL(), html)+ if intent == nil || intent.Type == autosolver.IntentNormal {+ result.Solved = true+ return result, nil+ }+ result.Error = fmt.Sprintf("challenge still present (%s)", intent.ChallengeType)+ return result, nil+}++func clickIfExists(ctx context.Context, executor autosolver.ActionExecutor, selector string) error {+ var coords struct {+ X float64 `json:"x"`+ Y float64 `json:"y"`+ }+ expr := fmt.Sprintf(`(() => {+ const el = document.querySelector(%q);+ if (!el) return null;+ const r = el.getBoundingClientRect();+ if (!r || r.width <= 0 || r.height <= 0) return null;+ return {x: r.x + r.width/2, y: r.y + r.height/2};+ })()`, selector)+ if err := executor.Evaluate(ctx, expr, &coords); err != nil {+ return err+ }+ if coords.X == 0 && coords.Y == 0 {+ return nil+ }+ return executor.Click(ctx, coords.X, coords.Y)+}diff --git a/internal/autosolver/solvers/jschallenge_test.go b/internal/autosolver/solvers/jschallenge_test.gonew file mode 100644index 00000000..ca4f369d--- /dev/null+++ b/internal/autosolver/solvers/jschallenge_test.go@@ -0,0 +1,160 @@+package solvers++import (+ "context"+ "errors"+ "testing"+ "time"++ "github.com/pinchtab/pinchtab/internal/autosolver"+)++type jsMockPage struct {+ title string+ url string+ htmlSeq []string+ idx int+}++func (m *jsMockPage) URL() string { return m.url }+func (m *jsMockPage) Title() string { return m.title }+func (m *jsMockPage) Screenshot() ([]byte, error) {+ return nil, nil+}+func (m *jsMockPage) HTML() (string, error) {+ if len(m.htmlSeq) == 0 {+ return "", nil+ }+ if m.idx >= len(m.htmlSeq) {+ return m.htmlSeq[len(m.htmlSeq)-1], nil+ }+ h := m.htmlSeq[m.idx]+ m.idx+++ return h, nil+}++type jsMockExecutor struct {+ clicks int+ evals int+ waits int+ clickErr error+ evaluateErr error+ waitErr error+}++func (m *jsMockExecutor) Click(_ context.Context, _, _ float64) error {+ m.clicks+++ return m.clickErr+}+func (m *jsMockExecutor) Type(_ context.Context, _ string) error { return nil }+func (m *jsMockExecutor) WaitFor(_ context.Context, _ string, _ time.Duration) error {+ m.waits+++ return m.waitErr+}+func (m *jsMockExecutor) Evaluate(_ context.Context, _ string, _ interface{}) error {+ m.evals+++ return m.evaluateErr+}+func (m *jsMockExecutor) Navigate(_ context.Context, _ string) error { return nil }++func TestJSChallenge_CanHandle(t *testing.T) {+ s := &JSChallenge{}+ page := &jsMockPage{+ title: "Browser Integrity Check",+ url: "https://example.com/challenge",+ htmlSeq: []string{+ `<script>window._cf_chl_opt = {}</script>`,+ },+ }+ ok, err := s.CanHandle(context.Background(), page)+ if err != nil {+ t.Fatalf("CanHandle error: %v", err)+ }+ if !ok {+ t.Fatal("expected CanHandle=true")+ }+}++func TestJSChallenge_SolveResolves(t *testing.T) {+ s := &JSChallenge{}+ page := &jsMockPage{+ title: "Browser Integrity Check",+ url: "https://example.com/challenge",+ htmlSeq: []string{+ `<script>window._cf_chl_opt = {}</script>`,+ `<html><body>still loading</body></html>`,+ `<html><body>ok</body></html>`,+ },+ }+ executor := &jsMockExecutor{}++ result, err := s.Solve(context.Background(), page, executor)+ if err != nil {+ t.Fatalf("Solve error: %v", err)+ }+ if !result.Solved {+ t.Fatalf("expected solved result, got error=%q", result.Error)+ }+ if executor.waits == 0 {+ t.Fatal("expected wait to be called")+ }+}++func TestJSChallenge_SolveWaitError(t *testing.T) {+ s := &JSChallenge{}+ page := &jsMockPage{+ title: "Browser Integrity Check",+ url: "https://example.com/challenge",+ htmlSeq: []string{+ `<script>window._cf_chl_opt = {}</script>`,+ },+ }+ executor := &jsMockExecutor{waitErr: errors.New("wait fail")}++ result, err := s.Solve(context.Background(), page, executor)+ if err == nil {+ t.Fatal("expected wait error")+ }+ if result == nil || result.Error == "" {+ t.Fatal("expected result error message")+ }+}++func TestJSChallenge_SolveContextCancel(t *testing.T) {+ s := &JSChallenge{}+ page := &jsMockPage{+ title: "Browser Integrity Check",+ url: "https://example.com/challenge",+ htmlSeq: []string{+ `<script>window._cf_chl_opt = {}</script>`,+ `<script>window._cf_chl_opt = {}</script>`,+ `<script>window._cf_chl_opt = {}</script>`,+ },+ }+ executor := &jsMockExecutor{}++ ctx, cancel := context.WithCancel(context.Background())+ cancel()++ result, err := s.Solve(ctx, page, executor)+ if err == nil {+ t.Fatal("expected context cancellation error")+ }+ if result == nil || result.Error == "" {+ t.Fatal("expected result with context error")+ }+}++func TestJSChallenge_UsesSharedDetection(t *testing.T) {+ intent := autosolver.DetectChallengeIntent(+ "Browser Integrity Check",+ "https://example.com/challenge",+ `<script>window._cf_chl_opt = {}</script>`,+ )+ if intent == nil {+ t.Fatal("expected shared detection intent")+ }+ if intent.ChallengeType != "custom-js" {+ t.Fatalf("expected custom-js challenge type, got %q", intent.ChallengeType)+ }+}diff --git a/internal/autosolver/types.go b/internal/autosolver/types.goindex a8d216a8..99cd2492 100644--- a/internal/autosolver/types.go+++ b/internal/autosolver/types.go@@ -10,6 +10,7 @@ const (IntentCaptcha IntentType = "captcha" // CAPTCHA challenge (Turnstile, reCAPTCHA, hCaptcha)IntentLogin IntentType = "login" // Login form detectedIntentSignup IntentType = "signup" // Signup/registration form detected+ IntentForm IntentType = "form" // Generic form-filling flow detectedIntentBlocked IntentType = "blocked" // Navigation blocked (interstitial, bot gate)IntentOnboarding IntentType = "onboarding" // Multi-step onboarding flowIntentNavigation IntentType = "navigation" // Multi-step navigation task@@ -131,7 +132,7 @@ func DefaultConfig() Config {Enabled: true,MaxAttempts: 8,SolverTimeout: 30 * time.Second,- Solvers: []string{"cloudflare", "semantic"},+ Solvers: []string{"cloudflare", "semantic", "capsolver", "twocaptcha"},LLMFallback: false,RetryBaseDelay: 500 * time.Millisecond,RetryMaxDelay: 10 * time.Second,diff --git a/internal/handlers/autosolver.go b/internal/handlers/autosolver.gonew file mode 100644index 00000000..760621e2--- /dev/null+++ b/internal/handlers/autosolver.go@@ -0,0 +1,232 @@+package handlers++import (+ "context"+ "errors"+ "log/slog"+ "strings"+ "time"++ coreautosolver "github.com/pinchtab/pinchtab/internal/autosolver"+ "github.com/pinchtab/pinchtab/internal/autosolver/adapters"+ "github.com/pinchtab/pinchtab/internal/autosolver/external"+ autosolversemantic "github.com/pinchtab/pinchtab/internal/autosolver/semantic"+ autosolvers "github.com/pinchtab/pinchtab/internal/autosolver/solvers"+)++const (+ autoSolverTriggerNavigate = "navigate"+ autoSolverTriggerAction = "action"+)++func (h *Handlers) maybeAutoSolve(ctx context.Context, tabID, trigger string) {+ if tabID == "" || h.autoSolverRunner == nil || !h.shouldAutoSolve(trigger) {+ return+ }+ if ctx == nil {+ ctx = context.Background()+ }++ if err := h.autoSolverRunner(ctx, tabID); err != nil &&+ !errors.Is(err, context.Canceled) &&+ !errors.Is(err, context.DeadlineExceeded) {+ slog.Warn("autosolver auto-trigger failed",+ "trigger", trigger,+ "tab_id", tabID,+ "error", err)+ }+}++func (h *Handlers) shouldAutoSolve(trigger string) bool {+ if h == nil || h.Config == nil {+ return false+ }++ cfg := h.Config.AutoSolver+ if !cfg.Enabled || !cfg.AutoTrigger {+ return false+ }++ switch trigger {+ case autoSolverTriggerNavigate:+ return cfg.TriggerOnNavigate+ case autoSolverTriggerAction:+ return cfg.TriggerOnAction+ default:+ return false+ }+}++func (h *Handlers) runAutoSolver(ctx context.Context, tabID string) error {+ if h == nil || h.Config == nil || h.Bridge == nil {+ return nil+ }++ page, executor, err := adapters.NewFromBridge(h.Bridge, tabID)+ if err != nil {+ return err+ }++ html, err := page.HTML()+ if err != nil {+ return err+ }++ // Auto-trigger focuses on challenge resolution and should be a no-op on normal pages.+ if coreautosolver.DetectChallengeIntent(page.Title(), page.URL(), html) == nil {+ return nil+ }++ cfg := h.normalizedAutoSolverConfig()+ as := h.buildAutoSolver(cfg, true)++ solveCtx, cancel := context.WithTimeout(ctx, estimateAutoSolverRunTimeout(cfg))+ defer cancel()++ result, err := as.Solve(solveCtx, page, executor)+ if err != nil {+ return err+ }++ if result != nil {+ if result.Solved && result.Attempts > 0 {+ slog.Info("autosolver auto-trigger solved challenge",+ "tab_id", tabID,+ "solver", result.SolverUsed,+ "attempts", result.Attempts)+ } else if !result.Solved && result.Attempts > 0 {+ slog.Warn("autosolver auto-trigger did not solve challenge",+ "tab_id", tabID,+ "attempts", result.Attempts,+ "error", result.Error)+ }+ }++ return nil+}++func (h *Handlers) normalizedAutoSolverConfig() coreautosolver.Config {+ cfg := coreautosolver.DefaultConfig()+ if h == nil || h.Config == nil {+ return cfg+ }++ cfg.Enabled = h.Config.AutoSolver.Enabled+ if h.Config.AutoSolver.MaxAttempts > 0 {+ cfg.MaxAttempts = h.Config.AutoSolver.MaxAttempts+ }+ if h.Config.AutoSolver.SolverTimeoutSec > 0 {+ cfg.SolverTimeout = time.Duration(h.Config.AutoSolver.SolverTimeoutSec) * time.Second+ }+ if h.Config.AutoSolver.RetryBaseDelayMs >= 0 {+ cfg.RetryBaseDelay = time.Duration(h.Config.AutoSolver.RetryBaseDelayMs) * time.Millisecond+ }+ if h.Config.AutoSolver.RetryMaxDelayMs >= 0 {+ cfg.RetryMaxDelay = time.Duration(h.Config.AutoSolver.RetryMaxDelayMs) * time.Millisecond+ }+ if len(h.Config.AutoSolver.Solvers) > 0 {+ configured := make([]string, 0, len(h.Config.AutoSolver.Solvers))+ for _, name := range h.Config.AutoSolver.Solvers {+ trimmed := strings.TrimSpace(name)+ if trimmed != "" {+ configured = append(configured, trimmed)+ }+ }+ if len(configured) > 0 {+ cfg.Solvers = configured+ }+ }+ cfg.LLMFallback = h.Config.AutoSolver.LLMFallback++ return cfg+}++func (h *Handlers) buildAutoSolver(cfg coreautosolver.Config, includeSemantic bool) *coreautosolver.AutoSolver {+ var semanticEngine coreautosolver.SemanticEngine+ if includeSemantic {+ semanticEngine = autosolversemantic.NewAdapter(h.Matcher)+ }++ as := coreautosolver.New(cfg, semanticEngine, nil)+ as.Registry().MustRegister(&autosolvers.Cloudflare{})+ as.Registry().MustRegister(&autosolvers.JSChallenge{})++ if h != nil && h.Config != nil {+ if key := strings.TrimSpace(h.Config.AutoSolver.CapsolverKey); key != "" {+ as.Registry().MustRegister(external.NewCapsolver(external.CapsolverConfig{APIKey: key}))+ }+ if key := strings.TrimSpace(h.Config.AutoSolver.TwoCaptchaKey); key != "" {+ as.Registry().MustRegister(external.NewTwoCaptcha(external.TwoCaptchaConfig{APIKey: key}))+ }+ }++ return as+}++func (h *Handlers) availableAutoSolverNames() []string {+ cfg := h.normalizedAutoSolverConfig()+ available := map[string]bool{+ "cloudflare": true,+ "semantic": true,+ "jschallenge": true,+ }+ if h != nil && h.Config != nil {+ if strings.TrimSpace(h.Config.AutoSolver.CapsolverKey) != "" {+ available["capsolver"] = true+ }+ if strings.TrimSpace(h.Config.AutoSolver.TwoCaptchaKey) != "" {+ available["twocaptcha"] = true+ }+ }++ names := make([]string, 0, len(available))+ seen := make(map[string]struct{}, len(available))+ for _, configured := range cfg.Solvers {+ if !available[configured] {+ continue+ }+ if _, ok := seen[configured]; ok {+ continue+ }+ names = append(names, configured)+ seen[configured] = struct{}{}+ }++ for _, fallback := range []string{"cloudflare", "semantic", "jschallenge", "capsolver", "twocaptcha"} {+ if !available[fallback] {+ continue+ }+ if _, ok := seen[fallback]; ok {+ continue+ }+ names = append(names, fallback)+ seen[fallback] = struct{}{}+ }++ return names+}++func (h *Handlers) isAvailableAutoSolver(name string) bool {+ for _, n := range h.availableAutoSolverNames() {+ if n == name {+ return true+ }+ }+ return false+}++func estimateAutoSolverRunTimeout(cfg coreautosolver.Config) time.Duration {+ attempts := cfg.MaxAttempts+ if attempts < 1 {+ attempts = 1+ }++ timeout := time.Duration(attempts) * cfg.SolverTimeout+ if attempts > 1 {+ timeout += time.Duration(attempts-1) * cfg.RetryMaxDelay+ }+ if timeout <= 0 {+ timeout = 30 * time.Second+ }+ return timeout + 2*time.Second+}diff --git a/internal/handlers/autosolver_test.go b/internal/handlers/autosolver_test.gonew file mode 100644index 00000000..47ccc772--- /dev/null+++ b/internal/handlers/autosolver_test.go@@ -0,0 +1,113 @@+package handlers++import (+ "context"+ "testing"++ "github.com/pinchtab/pinchtab/internal/config"+)++func TestShouldAutoSolve(t *testing.T) {+ tests := []struct {+ name string+ cfg *config.RuntimeConfig+ trigger string+ want bool+ }{+ {+ name: "nil config",+ cfg: nil,+ trigger: autoSolverTriggerNavigate,+ want: false,+ },+ {+ name: "disabled autosolver",+ cfg: &config.RuntimeConfig{AutoSolver: config.AutoSolverConfig{+ Enabled: false,+ AutoTrigger: true,+ TriggerOnNavigate: true,+ TriggerOnAction: true,+ }},+ trigger: autoSolverTriggerNavigate,+ want: false,+ },+ {+ name: "auto trigger disabled",+ cfg: &config.RuntimeConfig{AutoSolver: config.AutoSolverConfig{+ Enabled: true,+ AutoTrigger: false,+ TriggerOnNavigate: true,+ TriggerOnAction: true,+ }},+ trigger: autoSolverTriggerNavigate,+ want: false,+ },+ {+ name: "navigate trigger enabled",+ cfg: &config.RuntimeConfig{AutoSolver: config.AutoSolverConfig{+ Enabled: true,+ AutoTrigger: true,+ TriggerOnNavigate: true,+ TriggerOnAction: false,+ }},+ trigger: autoSolverTriggerNavigate,+ want: true,+ },+ {+ name: "action trigger disabled",+ cfg: &config.RuntimeConfig{AutoSolver: config.AutoSolverConfig{+ Enabled: true,+ AutoTrigger: true,+ TriggerOnNavigate: true,+ TriggerOnAction: false,+ }},+ trigger: autoSolverTriggerAction,+ want: false,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ h := &Handlers{Config: tt.cfg}+ if got := h.shouldAutoSolve(tt.trigger); got != tt.want {+ t.Fatalf("shouldAutoSolve(%q) = %v, want %v", tt.trigger, got, tt.want)+ }+ })+ }+}++func TestMaybeAutoSolve_InvokesRunnerWhenEnabled(t *testing.T) {+ h := &Handlers{+ Config: &config.RuntimeConfig{AutoSolver: config.AutoSolverConfig{+ Enabled: true,+ AutoTrigger: true,+ TriggerOnNavigate: true,+ TriggerOnAction: true,+ }},+ }++ calls := 0+ h.autoSolverRunner = func(_ context.Context, tabID string) error {+ calls+++ if tabID != "tab1" {+ t.Fatalf("runner tabID = %q, want tab1", tabID)+ }+ return nil+ }++ h.maybeAutoSolve(context.Background(), "tab1", autoSolverTriggerNavigate)+ if calls != 1 {+ t.Fatalf("autoSolverRunner calls = %d, want 1", calls)+ }++ h.maybeAutoSolve(context.Background(), "", autoSolverTriggerNavigate)+ if calls != 1 {+ t.Fatalf("autoSolverRunner calls with empty tab id = %d, want unchanged", calls)+ }++ h.Config.AutoSolver.TriggerOnNavigate = false+ h.maybeAutoSolve(context.Background(), "tab1", autoSolverTriggerNavigate)+ if calls != 1 {+ t.Fatalf("autoSolverRunner calls with navigate trigger disabled = %d, want unchanged", calls)+ }+}diff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.goindex 4e30e6ec..749758b8 100644--- a/internal/handlers/handlers.go+++ b/internal/handlers/handlers.go@@ -37,8 +37,9 @@ type Handlers struct {clipboard clipboardStore// Optional dependency injection (for unit testing)- evalJS func(ctx context.Context, expression string, out *string) error- evalRuntime func(ctx context.Context, expression string, out any, opts ...chromedp.EvaluateOption) error+ evalJS func(ctx context.Context, expression string, out *string) error+ autoSolverRunner func(ctx context.Context, tabID string) error+ evalRuntime func(ctx context.Context, expression string, out any, opts ...chromedp.EvaluateOption) error}func New(b bridge.BridgeAPI, cfg *config.RuntimeConfig, p bridge.ProfileService, d *dashboard.Dashboard, o bridge.OrchestratorService) *Handlers {@@ -97,6 +98,7 @@ func New(b bridge.BridgeAPI, cfg *config.RuntimeConfig, p bridge.ProfileService,h.evalJS = func(ctx context.Context, expression string, out *string) error {return chromedp.Run(ctx, chromedp.Evaluate(expression, out))}+ h.autoSolverRunner = h.runAutoSolverh.evalRuntime = func(ctx context.Context, expression string, out any, opts ...chromedp.EvaluateOption) error {return chromedp.Run(ctx, chromedp.Evaluate(expression, out, opts...))}@@ -209,6 +211,7 @@ func (h *Handlers) RegisterRoutes(mux *http.ServeMux, doShutdown func()) {mux.HandleFunc("GET /cookies", h.HandleGetCookies)mux.HandleFunc("POST /cookies", h.HandleSetCookies)mux.HandleFunc("GET /solvers", h.HandleListSolvers)+ mux.HandleFunc("GET /config/autosolver", h.HandleAutoSolverConfig)mux.HandleFunc("POST /solve", h.HandleSolve)mux.HandleFunc("POST /solve/{name}", h.HandleSolve)mux.HandleFunc("POST /tabs/{id}/solve", h.HandleTabSolve)diff --git a/internal/handlers/solver.go b/internal/handlers/solver.goindex d801d39e..98f9a9e4 100644--- a/internal/handlers/solver.go+++ b/internal/handlers/solver.go@@ -8,15 +8,12 @@ import ("fmt""io""net/http"- "strings""time""github.com/pinchtab/pinchtab/internal/activity"+ coreautosolver "github.com/pinchtab/pinchtab/internal/autosolver"+ "github.com/pinchtab/pinchtab/internal/autosolver/adapters""github.com/pinchtab/pinchtab/internal/httpx"- "github.com/pinchtab/pinchtab/internal/solver"-- // Register built-in solvers via init().- _ "github.com/pinchtab/pinchtab/internal/bridge")// HandleSolve attempts to solve a browser challenge on the current page.@@ -33,7 +30,7 @@ import (// @Param maxAttempts int body Max solve attempts (optional, default: 3)// @Param timeout float64 body Timeout in ms (optional, default: 30000)//-// @Response 200 application/json Returns {tabId, solver, solved, challengeType, attempts, title, needsHumanHandoff, handoffReason}+// @Response 200 application/json Returns {tabId, solver, solved, challengeType, attempts, title}// @Response 400 application/json Invalid request body or unknown solver// @Response 423 application/json Tab is locked by another owner// @Response 500 application/json Chrome/CDP error@@ -69,9 +66,9 @@ func (h *Handlers) HandleSolve(w http.ResponseWriter, r *http.Request) {// Validate solver name early.if req.Solver != "" {- if _, ok := solver.Get(req.Solver); !ok {+ if !h.isAvailableAutoSolver(req.Solver) {httpx.ErrorCode(w, 400, "unknown_solver",- fmt.Sprintf("unknown solver %q (available: %v)", req.Solver, solver.Names()),+ fmt.Sprintf("unknown solver %q (available: %v)", req.Solver, h.availableAutoSolverNames()),false, nil)return}@@ -99,23 +96,49 @@ func (h *Handlers) HandleSolve(w http.ResponseWriter, r *http.Request) {}h.recordActivity(r, activity.Update{Action: action, TabID: resolvedTabID})+ page, executor, err := adapters.NewFromBridge(h.Bridge, resolvedTabID)+ if err != nil {+ httpx.Error(w, 500, fmt.Errorf("resolve solve tab: %w", err))+ return+ }++ cfg := h.normalizedAutoSolverConfig()+ cfg.Enabled = true+ if req.MaxAttempts > 0 {+ cfg.MaxAttempts = req.MaxAttempts+ }+ if req.Solver != "" {+ cfg.Solvers = []string{req.Solver}+ }++ // Explicit named solvers should run directly without semantic-first flow,+ // except when the caller explicitly requested the semantic solver.+ includeSemantic := req.Solver == "" || req.Solver == "semantic"+ as := h.buildAutoSolver(cfg, includeSemantic)+timeout := 30 * time.Secondif req.Timeout > 0 {timeout = time.Duration(req.Timeout) * time.Millisecond+ } else {+ estimated := estimateAutoSolverRunTimeout(cfg)+ if estimated > timeout {+ timeout = estimated+ }}tCtx, tCancel := context.WithTimeout(ctx, timeout)defer tCancel()go httpx.CancelOnClientDone(r.Context(), tCancel)- result, err := solver.Solve(tCtx, req.Solver, solver.Options{- MaxAttempts: req.MaxAttempts,- })+ result, err := as.Solve(tCtx, page, executor)if err != nil {httpx.Error(w, 500, fmt.Errorf("solve: %w", err))return}- needsHumanHandoff, handoffReason := deriveHumanHandoff(result)+ if result == nil {+ httpx.Error(w, 500, fmt.Errorf("solve: empty result"))+ return+ }// Re-check domain policy after solve — the page may have redirected// to a different domain once the challenge was resolved.@@ -123,48 +146,24 @@ func (h *Handlers) HandleSolve(w http.ResponseWriter, r *http.Request) {return}- httpx.JSON(w, 200, map[string]any{- "tabId": resolvedTabID,- "solver": result.Solver,- "solved": result.Solved,- "challengeType": result.ChallengeType,- "attempts": result.Attempts,- "title": result.Title,- "needsHumanHandoff": needsHumanHandoff,- "handoffReason": handoffReason,- })-}--func deriveHumanHandoff(result *solver.Result) (bool, string) {- if result == nil || result.Solved {- return false, ""+ solverName := result.SolverUsed+ if solverName == "" && req.Solver != "" {+ solverName = req.Solver}- challengeType := strings.ToLower(strings.TrimSpace(result.ChallengeType))- title := strings.ToLower(strings.TrimSpace(result.Title))-- if strings.Contains(challengeType, "login") ||- strings.Contains(challengeType, "auth") ||- strings.Contains(challengeType, "credential") ||- strings.Contains(challengeType, "password") ||- strings.Contains(title, "sign in") ||- strings.Contains(title, "log in") ||- strings.Contains(title, "password") {- return true, "credentials_required"+ title := result.FinalTitle+ if title == "" {+ title = page.Title()}- if strings.Contains(challengeType, "captcha") ||- strings.Contains(challengeType, "turnstile") ||- strings.Contains(challengeType, "recaptcha") ||- strings.Contains(challengeType, "hcaptcha") ||- strings.Contains(challengeType, "challenge") ||- strings.Contains(title, "verify you are human") ||- strings.Contains(title, "attention required") ||- strings.Contains(title, "just a moment") {- return true, "challenge_requires_manual_intervention"- }-- return false, ""+ httpx.JSON(w, 200, map[string]any{+ "tabId": resolvedTabID,+ "solver": solverName,+ "solved": result.Solved,+ "challengeType": deriveChallengeType(result, page),+ "attempts": result.Attempts,+ "title": title,+ })}// HandleTabSolve handles POST /tabs/{id}/solve and /tabs/{id}/solve/{name}.@@ -207,6 +206,74 @@ func (h *Handlers) HandleTabSolve(w http.ResponseWriter, r *http.Request) {// @Response 200 application/json Returns {solvers: ["cloudflare", ...]}func (h *Handlers) HandleListSolvers(w http.ResponseWriter, r *http.Request) {httpx.JSON(w, 200, map[string]any{- "solvers": solver.Names(),+ "solvers": h.availableAutoSolverNames(),})}++// HandleAutoSolverConfig returns effective autosolver runtime settings.+//+// @Endpoint GET /config/autosolver+// @Description Return effective autosolver configuration and available solver names+// @Response 200 application/json Returns autosolver runtime config+func (h *Handlers) HandleAutoSolverConfig(w http.ResponseWriter, r *http.Request) {+ cfg := h.normalizedAutoSolverConfig()++ autoTrigger := true+ triggerOnNavigate := true+ triggerOnAction := true+ llmProvider := ""++ if h != nil && h.Config != nil {+ autoTrigger = h.Config.AutoSolver.AutoTrigger+ triggerOnNavigate = h.Config.AutoSolver.TriggerOnNavigate+ triggerOnAction = h.Config.AutoSolver.TriggerOnAction+ llmProvider = h.Config.AutoSolver.LLMProvider+ }++ httpx.JSON(w, 200, map[string]any{+ "enabled": cfg.Enabled,+ "autoTrigger": autoTrigger,+ "triggerOnNavigate": triggerOnNavigate,+ "triggerOnAction": triggerOnAction,+ "maxAttempts": cfg.MaxAttempts,+ "solverTimeoutSec": int(cfg.SolverTimeout / time.Second),+ "retryBaseDelayMs": int(cfg.RetryBaseDelay / time.Millisecond),+ "retryMaxDelayMs": int(cfg.RetryMaxDelay / time.Millisecond),+ "solvers": h.availableAutoSolverNames(),+ "llmProvider": llmProvider,+ "llmFallback": cfg.LLMFallback,+ })+}++func deriveChallengeType(result *coreautosolver.Result, page coreautosolver.Page) string {+ if result == nil || page == nil {+ return ""+ }++ finalTitle := result.FinalTitle+ if finalTitle == "" {+ finalTitle = page.Title()+ }+ finalURL := result.FinalURL+ if finalURL == "" {+ finalURL = page.URL()+ }++ html, err := page.HTML()+ if err == nil {+ if detected := coreautosolver.DetectChallengeIntent(finalTitle, finalURL, html); detected != nil {+ if detected.ChallengeType != "" {+ return detected.ChallengeType+ }+ if detected.Type != "" && detected.Type != coreautosolver.IntentNormal {+ return string(detected.Type)+ }+ }+ }++ if result.Intent != "" && result.Intent != coreautosolver.IntentNormal {+ return string(result.Intent)+ }++ return ""+}diff --git a/internal/handlers/solver_test.go b/internal/handlers/solver_test.goindex 7373cf0f..32923edb 100644--- a/internal/handlers/solver_test.go+++ b/internal/handlers/solver_test.go@@ -2,31 +2,15 @@ package handlersimport ("bytes"- "context""encoding/json"- "fmt""net/http""net/http/httptest""testing"+ coreautosolver "github.com/pinchtab/pinchtab/internal/autosolver""github.com/pinchtab/pinchtab/internal/config"- "github.com/pinchtab/pinchtab/internal/solver")-type testStaticSolver struct {- name string- result *solver.Result- err error-}--func (s *testStaticSolver) Name() string { return s.name }-func (s *testStaticSolver) CanHandle(context.Context) (bool, error) {- return true, nil-}-func (s *testStaticSolver) Solve(context.Context, solver.Options) (*solver.Result, error) {- return s.result, s.err-}-func TestHandleListSolvers(t *testing.T) {h := New(&mockBridge{}, &config.RuntimeConfig{}, nil, nil, nil)@@ -47,17 +31,69 @@ func TestHandleListSolvers(t *testing.T) {t.Fatal("expected 'solvers' key in response")}- // cloudflare solver is registered via bridge init- found := false+ foundCloudflare := false+ foundSemantic := falsefor _, s := range solvers {if s == "cloudflare" {- found = true- break+ foundCloudflare = true+ }+ if s == "semantic" {+ foundSemantic = true}}- if !found {+ if !foundCloudflare {t.Errorf("expected cloudflare in solvers list, got %v", solvers)}+ if !foundSemantic {+ t.Errorf("expected semantic in solvers list, got %v", solvers)+ }+}++func TestHandleAutoSolverConfig(t *testing.T) {+ h := New(&mockBridge{}, &config.RuntimeConfig{+ AutoSolver: config.AutoSolverConfig{+ Enabled: true,+ AutoTrigger: true,+ TriggerOnNavigate: false,+ TriggerOnAction: true,+ MaxAttempts: 5,+ SolverTimeoutSec: 42,+ RetryBaseDelayMs: 200,+ RetryMaxDelayMs: 1200,+ Solvers: []string{"cloudflare", "semantic", "jschallenge"},+ LLMProvider: "openai",+ LLMFallback: true,+ },+ }, nil, nil, nil)++ req := httptest.NewRequest("GET", "/config/autosolver", nil)+ w := httptest.NewRecorder()+ h.HandleAutoSolverConfig(w, req)++ if w.Code != 200 {+ t.Fatalf("expected 200, got %d", w.Code)+ }++ var resp map[string]any+ if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {+ t.Fatalf("decode response: %v", err)+ }++ if got, ok := resp["enabled"].(bool); !ok || !got {+ t.Fatalf("enabled = %v, want true", resp["enabled"])+ }+ if got, ok := resp["triggerOnNavigate"].(bool); !ok || got {+ t.Fatalf("triggerOnNavigate = %v, want false", resp["triggerOnNavigate"])+ }+ if got, ok := resp["solverTimeoutSec"].(float64); !ok || int(got) != 42 {+ t.Fatalf("solverTimeoutSec = %v, want 42", resp["solverTimeoutSec"])+ }+ if got, ok := resp["llmProvider"].(string); !ok || got != "openai" {+ t.Fatalf("llmProvider = %v, want openai", resp["llmProvider"])+ }+ if got, ok := resp["solvers"].([]any); !ok || len(got) == 0 {+ t.Fatalf("solvers = %v, want non-empty array", resp["solvers"])+ }}func TestHandleSolve_InvalidBody(t *testing.T) {@@ -185,9 +221,10 @@ func TestHandleSolve_PathUnknownSolver(t *testing.T) {}}-// Verify solver.Names includes cloudflare (registered by bridge init).+// Verify the HTTP-exposed solver list includes cloudflare.func TestCloudflareSolverRegistered(t *testing.T) {- names := solver.Names()+ h := New(&mockBridge{}, &config.RuntimeConfig{}, nil, nil, nil)+ names := h.availableAutoSolverNames()found := falsefor _, n := range names {if n == "cloudflare" {@@ -200,119 +237,9 @@ func TestCloudflareSolverRegistered(t *testing.T) {}}-func TestDeriveHumanHandoff(t *testing.T) {- tests := []struct {- name string- result *solver.Result- wantNeeded bool- wantReason string- }{- {- name: "solved result does not require handoff",- result: &solver.Result{Solved: true, ChallengeType: "turnstile"},- wantNeeded: false,- wantReason: "",- },- {- name: "captcha challenge requires handoff",- result: &solver.Result{Solved: false, ChallengeType: "cloudflare-turnstile"},- wantNeeded: true,- wantReason: "challenge_requires_manual_intervention",- },- {- name: "credential gate requires handoff",- result: &solver.Result{Solved: false, ChallengeType: "login"},- wantNeeded: true,- wantReason: "credentials_required",- },- {- name: "title heuristics detect credentials requirement",- result: &solver.Result{Solved: false, Title: "Sign In - Example"},- wantNeeded: true,- wantReason: "credentials_required",- },- }-- for _, tt := range tests {- t.Run(tt.name, func(t *testing.T) {- gotNeeded, gotReason := deriveHumanHandoff(tt.result)- if gotNeeded != tt.wantNeeded || gotReason != tt.wantReason {- t.Fatalf("deriveHumanHandoff() = (%v, %q), want (%v, %q)", gotNeeded, gotReason, tt.wantNeeded, tt.wantReason)- }- })- }-}--func TestHandleSolve_AndTabSolve_IncludeHandoffFields(t *testing.T) {- name := "test-handoff-static"- if err := solver.Register(name, &testStaticSolver{- name: name,- result: &solver.Result{- Solver: name,- Solved: false,- ChallengeType: "turnstile",- Attempts: 1,- Title: "Just a moment...",- },- }); err != nil {- t.Fatalf("register test solver: %v", err)+func TestDeriveChallengeType_NilPage(t *testing.T) {+ result := &coreautosolver.Result{Intent: coreautosolver.IntentCaptcha}+ if got := deriveChallengeType(result, nil); got != "" {+ t.Fatalf("deriveChallengeType(nil page) = %q, want empty string", got)}- t.Cleanup(func() { solver.Unregister(name) })-- h := New(&mockBridge{}, &config.RuntimeConfig{}, nil, nil, nil)-- t.Run("solve route", func(t *testing.T) {- body := fmt.Sprintf(`{"solver": %q, "maxAttempts": 1}`, name)- req := httptest.NewRequest("POST", "/solve", bytes.NewReader([]byte(body)))- w := httptest.NewRecorder()- h.HandleSolve(w, req)-- if w.Code != 200 {- t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())- }-- var resp map[string]any- if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {- t.Fatalf("decode response: %v", err)- }-- if _, ok := resp["needsHumanHandoff"]; !ok {- t.Fatalf("expected needsHumanHandoff field in response: %#v", resp)- }- if _, ok := resp["handoffReason"]; !ok {- t.Fatalf("expected handoffReason field in response: %#v", resp)- }- if needed, _ := resp["needsHumanHandoff"].(bool); !needed {- t.Fatalf("expected needsHumanHandoff=true, got: %#v", resp["needsHumanHandoff"])- }- if reason, _ := resp["handoffReason"].(string); reason != "challenge_requires_manual_intervention" {- t.Fatalf("expected handoffReason=challenge_requires_manual_intervention, got: %#v", resp["handoffReason"])- }- })-- t.Run("tab solve route", func(t *testing.T) {- mux := http.NewServeMux()- h.RegisterRoutes(mux, nil)-- body := fmt.Sprintf(`{"solver": %q, "maxAttempts": 1}`, name)- req := httptest.NewRequest("POST", "/tabs/tab1/solve", bytes.NewReader([]byte(body)))- w := httptest.NewRecorder()- mux.ServeHTTP(w, req)-- if w.Code != 200 {- t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())- }-- var resp map[string]any- if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {- t.Fatalf("decode response: %v", err)- }-- if _, ok := resp["needsHumanHandoff"]; !ok {- t.Fatalf("expected needsHumanHandoff field in response: %#v", resp)- }- if _, ok := resp["handoffReason"]; !ok {- t.Fatalf("expected handoffReason field in response: %#v", resp)- }- })}diff --git a/internal/routes/routes.go b/internal/routes/routes.goindex 41be8b96..973c64c0 100644--- a/internal/routes/routes.go+++ b/internal/routes/routes.go@@ -71,11 +71,6 @@ var coreEndpoints = []Endpoint{{"POST", "/lock", "Lock tab", CapNone, true},{"POST", "/unlock", "Unlock tab", CapNone, true},- // Human handoff- {"POST", "/handoff", "Pause tab for human handoff", CapNone, true},- {"POST", "/resume", "Resume paused tab", CapNone, true},- {"GET", "/handoff", "Get handoff status", CapNone, true},-// Cookies{"GET", "/cookies", "Get cookies", CapNone, true},{"POST", "/cookies", "Set cookies", CapNone, true},@@ -109,6 +104,7 @@ var coreEndpoints = []Endpoint{// Solvers{"GET", "/solvers", "List available solvers", CapNone, false},+ {"GET", "/config/autosolver", "Get autosolver runtime config", CapNone, false},{"POST", "/solve", "Run default solver", CapNone, true},{"POST", "/solve/{name}", "Run named solver", CapNone, true},