Skip to content

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.go
index 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.Context
tabID 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.Context
tabID 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.go
index 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 *Registry
semantic 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 history
func (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 = true
result.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 = &copy
+ }
+
+ 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 *LLMRespon
switch 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.go
index 66fc7874..66573149 100644
--- a/internal/autosolver/autosolver_test.go
+++ b/internal/autosolver/autosolver_test.go
@@ -24,6 +24,9 @@ type mockExecutor struct {
clickCalled int
typeCalled int
navigateCalled 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 string
priority int
canHandle bool
+ solved bool
order *[]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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 patterns
cfPatterns := []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 patterns
blockedPatterns := []string{"access denied", "forbidden", "blocked", "unauthorized"}
for _, p := range blockedPatterns {
diff --git a/internal/autosolver/semantic/adapter.go b/internal/autosolver/semantic/adapter.go
index 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 indicators
cfIndicators := []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, inten
return 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 := 0
for {
- 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 detected
IntentSignup IntentType = "signup" // Signup/registration form detected
+ IntentForm IntentType = "form" // Generic form-filling flow detected
IntentBlocked IntentType = "blocked" // Navigation blocked (interstitial, bot gate)
IntentOnboarding IntentType = "onboarding" // Multi-step onboarding flow
IntentNavigation 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.runAutoSolver
h.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.go
index 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.Second
if 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.go
index 7373cf0f..32923edb 100644
--- a/internal/handlers/solver_test.go
+++ b/internal/handlers/solver_test.go
@@ -2,31 +2,15 @@ package handlers
import (
"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 := false
for _, 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 := false
for _, 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.go
index 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},