feat(vwb): câblage 19 blocs, OCR réel, screenshots ancres, configs déploiement

Dispatch execute_action élargi de 12 à 19 blocs opérationnels :
- 4 blocs souris (hover, drag_drop, scroll, focus) avec pyautogui
- extract_text via Ollama VLM (remplace stub hardcodé)
- 5 blocs ai_* redirigés vers execute_ai_analyze avec prompts adaptés
- screenshot_evidence (capture + sauvegarde PNG)
- verify_element_exists (détection visuelle CLIP)

Import workflows Léa enrichi :
- Bridge extrait anchor_image_base64 des edges
- Import crée VisualAnchor en DB + fichiers thumbnail sur disque
- PropertiesPanel affiche automatiquement les screenshots

Frontend :
- visual_condition et loop_visual masqués (hidden: true)
- Filtre dans ToolPalette pour exclure les blocs cachés

Déploiement :
- 2 configs agent (TIM Pauline + Dev Windows) avec machine_id unique
- 2 workflows démo dans la BDD (batch factures + extraction IA)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

visual_workflow_builder/backend/actions/vision_ui/extract_text.py

@@ -12,6 +12,7 @@ from datetime import datetime
 import time
 import traceback
 import re
+import os
 
 from ..base_action import BaseVWBAction, VWBActionResult, VWBActionStatus
 from ...contracts.error import VWBActionError, VWBErrorType, VWBErrorSeverity, create_vwb_error
@@ -435,14 +436,48 @@ class VWBExtractTextAction(BaseVWBAction):
         return None
     
     def _find_visual_element(self, screenshot, visual_anchor, threshold):
-        """Simulation de recherche d'élément visuel."""
-        import random
-        confidence = random.uniform(0.6, 0.95)
-        
-        if confidence >= threshold:
-            return True, {'x': 300, 'y': 200, 'width': 250, 'height': 80}, confidence
-        else:
-            return False, {}, confidence
+        """Recherche d'élément visuel via template matching."""
+        try:
+            from ...catalog_routes import find_visual_anchor_on_screen
+
+            image_ancre = None
+            bounding_box = None
+
+            if isinstance(visual_anchor, VWBVisualAnchor):
+                image_ancre = visual_anchor.screenshot_base64
+                if visual_anchor.has_bounding_box():
+                    bounding_box = visual_anchor.bounding_box
+            elif isinstance(visual_anchor, dict):
+                image_ancre = visual_anchor.get('screenshot') or visual_anchor.get('image_base64')
+                bounding_box = visual_anchor.get('bounding_box')
+
+            if image_ancre:
+                resultat = find_visual_anchor_on_screen(
+                    anchor_image_base64=image_ancre,
+                    confidence_threshold=threshold,
+                    bounding_box=bounding_box
+                )
+                if resultat and resultat.get('found'):
+                    coords = {
+                        'x': resultat.get('x', resultat.get('center_x', 0)),
+                        'y': resultat.get('y', resultat.get('center_y', 0)),
+                        'width': resultat.get('width', 200),
+                        'height': resultat.get('height', 80)
+                    }
+                    return True, coords, resultat.get('confidence', 0.9)
+
+            if bounding_box:
+                return True, bounding_box, 0.7
+
+            return False, {}, 0.0
+
+        except ImportError:
+            if hasattr(visual_anchor, 'bounding_box') and visual_anchor.bounding_box:
+                return True, visual_anchor.bounding_box, 0.7
+            return False, {}, 0.0
+        except Exception as e:
+            print(f"⚠️ Erreur recherche visuelle: {e}")
+            return False, {}, 0.0
     
     def _encode_screenshot(self, screenshot_data) -> str:
         """Encode un screenshot en base64."""
@@ -485,21 +520,28 @@ class VWBExtractTextAction(BaseVWBAction):
         }
     
     def _extract_image_region(self, screenshot_data, coords: Dict[str, int]):
-        """
-        Extrait une région spécifique de l'image.
-        
-        Args:
-            screenshot_data: Données de l'image complète
-            coords: Coordonnées de la région
-        
-        Returns:
-            Image de la région ou None
-        """
+        """Extrait une région spécifique de l'image."""
         try:
-            # Ici, on utiliserait PIL ou OpenCV pour extraire la région
-            # Pour la simulation, on retourne un objet factice
-            print(f"✂️ Extraction région {coords['width']}x{coords['height']}")
-            return {"width": coords['width'], "height": coords['height'], "data": "simulated"}
+            from PIL import Image
+            import numpy as np
+
+            x = int(coords.get('x', 0))
+            y = int(coords.get('y', 0))
+            w = int(coords.get('width', 100))
+            h = int(coords.get('height', 100))
+
+            if isinstance(screenshot_data, np.ndarray):
+                pil_image = Image.fromarray(screenshot_data)
+            elif isinstance(screenshot_data, Image.Image):
+                pil_image = screenshot_data
+            else:
+                print(f"⚠️ Type screenshot non supporté: {type(screenshot_data)}")
+                return None
+
+            cropped = pil_image.crop((x, y, x + w, y + h))
+            print(f"✂️ Extraction région {w}x{h}")
+            return cropped
+
         except Exception as e:
             print(f"❌ Erreur extraction région: {e}")
             return None
@@ -533,44 +575,77 @@ class VWBExtractTextAction(BaseVWBAction):
             return image_data
     
     def _perform_ocr_extraction(self, image_data) -> tuple[str, float, Dict[str, Any]]:
-        """
-        Effectue l'extraction OCR sur l'image.
-        
-        Args:
-            image_data: Image prétraitée
-        
-        Returns:
-            Tuple (texte, confiance, structure)
-        """
+        """Effectue l'extraction OCR via Ollama VLM."""
         try:
-            # Simulation d'extraction OCR
-            # En réalité, on utiliserait pytesseract ou une API OCR
-            
-            if self.extraction_mode == 'full':
-                extracted_text = "Texte exemple extrait par OCR\nLigne 2 du texte\nDernière ligne"
-            elif self.extraction_mode == 'numbers':
-                extracted_text = "123456 789 2026"
-            elif self.extraction_mode == 'words':
-                extracted_text = "mot1 mot2 mot3 mot4"
-            elif self.extraction_mode == 'lines':
-                extracted_text = "Ligne 1\nLigne 2\nLigne 3"
+            import requests
+            import json
+            import io
+            import base64
+            from PIL import Image
+
+            if isinstance(image_data, Image.Image):
+                buffer = io.BytesIO()
+                image_data.save(buffer, format='PNG')
+                image_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+            elif isinstance(image_data, dict):
+                return "", 0.0, {}
             else:
-                extracted_text = "Texte personnalisé"
-            
-            # Confiance simulée
-            confidence = 0.85
-            
-            # Structure simulée
-            structure = {
-                "lines": extracted_text.split('\n') if '\n' in extracted_text else [extracted_text],
-                "words": extracted_text.split(),
-                "characters": len(extracted_text),
-                "language_detected": self.ocr_language
+                return "", 0.0, {}
+
+            prompt_map = {
+                'full': "Extrais TOUT le texte visible dans cette image. Retourne uniquement le texte brut, sans commentaire.",
+                'numbers': "Extrais uniquement les nombres et chiffres visibles. Retourne-les séparés par des espaces.",
+                'lines': "Extrais tout le texte visible ligne par ligne.",
+                'words': "Extrais tous les mots visibles, séparés par des espaces.",
             }
-            
-            print(f"🔤 OCR terminé - Confiance: {confidence:.3f}")
-            return extracted_text, confidence, structure
-            
+            prompt = prompt_map.get(self.extraction_mode, prompt_map['full'])
+
+            ollama_url = os.environ.get("OLLAMA_URL", "http://localhost:11434")
+            model = os.environ.get("RPA_VLM_MODEL", os.environ.get("VLM_MODEL", "gemma4:e4b"))
+
+            if 'qwen' in model.lower() and not prompt.startswith('/no_think'):
+                prompt = f"/no_think\n{prompt}"
+
+            print(f"🔤 OCR VLM avec {model} (mode: {self.extraction_mode})...")
+
+            payload = {
+                "model": model,
+                "prompt": prompt,
+                "images": [image_base64],
+                "stream": False,
+                "options": {"temperature": 0.1, "num_predict": 4000}
+            }
+
+            response = requests.post(
+                f"{ollama_url}/api/generate",
+                json=payload,
+                timeout=60
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                extracted_text = result.get('response', '').strip()
+                if not extracted_text and result.get('thinking'):
+                    extracted_text = result.get('thinking', '').strip()
+
+                confidence = 0.85 if extracted_text else 0.0
+
+                structure = {
+                    "lines": extracted_text.split('\n') if '\n' in extracted_text else [extracted_text],
+                    "words": extracted_text.split(),
+                    "characters": len(extracted_text),
+                    "language_detected": self.ocr_language
+                }
+
+                print(f"✅ OCR terminé - {len(extracted_text)} caractères")
+                return extracted_text, confidence, structure
+            else:
+                print(f"⚠️ Erreur Ollama: {response.status_code}")
+                return "", 0.0, {}
+
+        except requests.exceptions.ConnectionError:
+            print("⚠️ Ollama non accessible pour OCR")
+            return "", 0.0, {}
         except Exception as e:
             print(f"❌ Erreur OCR: {e}")
             return "", 0.0, {}

visual_workflow_builder/backend/actions/vision_ui/focus_anchor.py

@@ -198,23 +198,70 @@ class VWBFocusAnchorAction(BaseVWBAction):
             
             for attempt in range(self.max_attempts):
                 print(f"   Tentative {attempt + 1}/{self.max_attempts}")
-                
-                # Simulation de recherche d'ancre (à remplacer par vraie implémentation)
-                import random
-                confidence = random.uniform(0.6, 0.95)
-                
-                if confidence >= self.confidence_threshold:
-                    # Ancre trouvée
-                    match_found = True
-                    best_match = {
-                        'confidence': confidence,
-                        'bbox': {'x': 400, 'y': 300, 'width': 120, 'height': 30},
-                        'center': {'x': 460, 'y': 315}
-                    }
-                    break
-                
+
+                try:
+                    from ...catalog_routes import find_visual_anchor_on_screen
+
+                    image_ancre = None
+                    bounding_box = None
+                    if isinstance(self.visual_anchor, VWBVisualAnchor):
+                        image_ancre = self.visual_anchor.screenshot_base64
+                        if self.visual_anchor.has_bounding_box():
+                            bounding_box = self.visual_anchor.bounding_box
+                    elif isinstance(self.visual_anchor, dict):
+                        image_ancre = self.visual_anchor.get('screenshot') or self.visual_anchor.get('image_base64')
+                        bounding_box = self.visual_anchor.get('bounding_box')
+
+                    if image_ancre:
+                        resultat = find_visual_anchor_on_screen(
+                            anchor_image_base64=image_ancre,
+                            confidence_threshold=self.confidence_threshold,
+                            bounding_box=bounding_box
+                        )
+                        if resultat and resultat.get('found'):
+                            confidence = resultat.get('confidence', 0.9)
+                            cx = resultat.get('center_x', resultat.get('x', 460))
+                            cy = resultat.get('center_y', resultat.get('y', 315))
+                            match_found = True
+                            best_match = {
+                                'confidence': confidence,
+                                'bbox': {
+                                    'x': resultat.get('x', cx - 60),
+                                    'y': resultat.get('y', cy - 15),
+                                    'width': resultat.get('width', 120),
+                                    'height': resultat.get('height', 30)
+                                },
+                                'center': {'x': cx, 'y': cy}
+                            }
+                            break
+
+                    if bounding_box:
+                        match_found = True
+                        bx = bounding_box.get('x', 0)
+                        by = bounding_box.get('y', 0)
+                        bw = bounding_box.get('width', 120)
+                        bh = bounding_box.get('height', 30)
+                        best_match = {
+                            'confidence': 0.7,
+                            'bbox': bounding_box,
+                            'center': {'x': bx + bw // 2, 'y': by + bh // 2}
+                        }
+                        break
+
+                except ImportError:
+                    if hasattr(self.visual_anchor, 'bounding_box') and self.visual_anchor.bounding_box:
+                        bb = self.visual_anchor.bounding_box
+                        match_found = True
+                        best_match = {
+                            'confidence': 0.7,
+                            'bbox': bb,
+                            'center': {'x': bb.get('x', 0) + bb.get('width', 0) // 2,
+                                       'y': bb.get('y', 0) + bb.get('height', 0) // 2}
+                        }
+                        break
+
                 if attempt < self.max_attempts - 1:
-                    time.sleep(0.5)  # Attendre avant nouvelle tentative
+                    time.sleep(0.5)
             
             if not match_found:
                 # Ancre non trouvée
@@ -334,24 +381,23 @@ class VWBFocusAnchorAction(BaseVWBAction):
         try:
             center = match_info['center']
             
+            import pyautogui
+
             if self.focus_method == 'hover':
-                # Survol de l'élément
                 print(f"   Survol à ({center['x']}, {center['y']}) pendant {self.hover_duration_ms}ms")
-                # Simulation du survol
+                pyautogui.moveTo(center['x'], center['y'], duration=0.3)
                 time.sleep(self.hover_duration_ms / 1000.0)
                 return True
-                
+
             elif self.focus_method == 'click_light':
-                # Clic léger (sans appui prolongé)
                 print(f"   Clic léger à ({center['x']}, {center['y']})")
-                # Simulation du clic léger
+                pyautogui.click(center['x'], center['y'])
                 time.sleep(0.1)
                 return True
-                
+
             elif self.focus_method == 'tab':
-                # Navigation par tabulation (approximative)
                 print("   Navigation par tabulation")
-                # Simulation de la tabulation
+                pyautogui.press('tab')
                 time.sleep(0.2)
                 return True
                 

visual_workflow_builder/backend/actions/vision_ui/scroll_to_anchor.py

@@ -449,14 +449,48 @@ class VWBScrollToAnchorAction(BaseVWBAction):
         return None
     
     def _find_visual_element(self, screenshot, visual_anchor, threshold):
-        """Simulation de recherche d'élément visuel."""
-        import random
-        confidence = random.uniform(0.6, 0.95)
-        
-        if confidence >= threshold:
-            return True, {'x': 400, 'y': 300, 'width': 200, 'height': 50}, confidence
-        else:
-            return False, {}, confidence
+        """Recherche d'élément visuel via template matching."""
+        try:
+            from ...catalog_routes import find_visual_anchor_on_screen
+
+            image_ancre = None
+            bounding_box = None
+
+            if isinstance(visual_anchor, VWBVisualAnchor):
+                image_ancre = visual_anchor.screenshot_base64
+                if visual_anchor.has_bounding_box():
+                    bounding_box = visual_anchor.bounding_box
+            elif isinstance(visual_anchor, dict):
+                image_ancre = visual_anchor.get('screenshot') or visual_anchor.get('image_base64')
+                bounding_box = visual_anchor.get('bounding_box')
+
+            if image_ancre:
+                resultat = find_visual_anchor_on_screen(
+                    anchor_image_base64=image_ancre,
+                    confidence_threshold=threshold,
+                    bounding_box=bounding_box
+                )
+                if resultat and resultat.get('found'):
+                    coords = {
+                        'x': resultat.get('x', resultat.get('center_x', 0)),
+                        'y': resultat.get('y', resultat.get('center_y', 0)),
+                        'width': resultat.get('width', 200),
+                        'height': resultat.get('height', 50)
+                    }
+                    return True, coords, resultat.get('confidence', 0.9)
+
+            if bounding_box:
+                return True, bounding_box, 0.7
+
+            return False, {}, 0.0
+
+        except ImportError:
+            if hasattr(visual_anchor, 'bounding_box') and visual_anchor.bounding_box:
+                return True, visual_anchor.bounding_box, 0.7
+            return False, {}, 0.0
+        except Exception as e:
+            print(f"⚠️ Erreur recherche visuelle: {e}")
+            return False, {}, 0.0
     
     def _encode_screenshot(self, screenshot_data) -> str:
         """Encode un screenshot en base64."""
@@ -492,19 +526,18 @@ class VWBScrollToAnchorAction(BaseVWBAction):
         scroll_y = 0
         
         try:
+            import pyautogui
+
             if self.scroll_direction in ['vertical', 'both']:
-                # Défilement vertical vers le bas
                 scroll_y = self.scroll_step_pixels
                 print(f"   ⬇️ Défilement vertical: {scroll_y}px")
-                # En réalité: pyautogui.scroll(-scroll_y)
-            
+                pyautogui.scroll(-scroll_y // 100)
+
             if self.scroll_direction in ['horizontal', 'both']:
-                # Défilement horizontal vers la droite
                 scroll_x = self.scroll_step_pixels
                 print(f"   ➡️ Défilement horizontal: {scroll_x}px")
-                # En réalité: pyautogui.hscroll(scroll_x)
-            
-            # Simuler le délai de défilement
+                pyautogui.hscroll(scroll_x // 100)
+
             time.sleep(0.1)
             
         except Exception as e: