fix(vwb): Corriger l'exécution VWB pour toutes les étapes
- Ajouter liste des 20 types d'actions VWB connus pour détection fiable - Corriger isVWBStep() pour vérifier step.type en priorité - Corriger extraction actionId (step.type au lieu de "unknown") - Résoudre problème stale closure en passant steps en paramètre - Ajouter logs de débogage détaillés pour suivi exécution Les étapes type_text sont maintenant correctement exécutées au lieu d'être simulées. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Dom
539
visual_workflow_builder/frontend/src/hooks/useVWBExecution.ts
Normal file
539
visual_workflow_builder/frontend/src/hooks/useVWBExecution.ts
Normal file
@@ -0,0 +1,539 @@
|
|||||||
|
/**
|
||||||
|
* Hook d'Exécution VWB - Gestion de l'exécution des workflows avec actions VisionOnly
|
||||||
|
* Auteur : Dom, Alice, Kiro - 10 janvier 2026
|
||||||
|
*
|
||||||
|
* Ce hook gère l'exécution complète des workflows VWB avec gestion d'état,
|
||||||
|
* feedback en temps réel et intégration avec les Evidence.
|
||||||
|
*/
|
||||||
|
|
||||||
|
import { useState, useCallback, useEffect, useRef } from 'react';
|
||||||
|
import {
|
||||||
|
vwbExecutionService,
|
||||||
|
VWBExecutionResult,
|
||||||
|
VWBExecutionOptions,
|
||||||
|
VWBExecutionContext
|
||||||
|
} from '../services/vwbExecutionService';
|
||||||
|
import {
|
||||||
|
Workflow,
|
||||||
|
Step,
|
||||||
|
StepExecutionState,
|
||||||
|
ExecutionState,
|
||||||
|
ExecutionError,
|
||||||
|
Evidence,
|
||||||
|
Variable
|
||||||
|
} from '../types';
|
||||||
|
|
||||||
|
export interface VWBExecutionState {
|
||||||
|
status: 'idle' | 'running' | 'paused' | 'completed' | 'error';
|
||||||
|
currentStepIndex: number;
|
||||||
|
currentStep: Step | null;
|
||||||
|
totalSteps: number;
|
||||||
|
completedSteps: number;
|
||||||
|
failedSteps: number;
|
||||||
|
startTime: Date | null;
|
||||||
|
endTime: Date | null;
|
||||||
|
duration: number;
|
||||||
|
progress: number;
|
||||||
|
results: VWBExecutionResult[];
|
||||||
|
errors: ExecutionError[];
|
||||||
|
evidence: Evidence[];
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface VWBExecutionCallbacks {
|
||||||
|
onStepStart?: (step: Step, index: number) => void;
|
||||||
|
onStepComplete?: (step: Step, result: VWBExecutionResult) => void;
|
||||||
|
onStepError?: (step: Step, error: ExecutionError) => void;
|
||||||
|
onExecutionComplete?: (success: boolean, summary: VWBExecutionSummary) => void;
|
||||||
|
onEvidenceGenerated?: (stepId: string, evidence: Evidence[]) => void;
|
||||||
|
onProgressUpdate?: (progress: number, currentStep: Step) => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface VWBExecutionSummary {
|
||||||
|
totalSteps: number;
|
||||||
|
completedSteps: number;
|
||||||
|
failedSteps: number;
|
||||||
|
skippedSteps: number;
|
||||||
|
duration: number;
|
||||||
|
successRate: number;
|
||||||
|
results: VWBExecutionResult[];
|
||||||
|
errors: ExecutionError[];
|
||||||
|
evidence: Evidence[];
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface UseVWBExecutionOptions {
|
||||||
|
autoValidate?: boolean;
|
||||||
|
generateEvidence?: boolean;
|
||||||
|
retryAttempts?: number;
|
||||||
|
timeout?: number;
|
||||||
|
pauseOnError?: boolean;
|
||||||
|
skipNonVWBSteps?: boolean;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Hook principal pour l'exécution des workflows VWB
|
||||||
|
*/
|
||||||
|
export const useVWBExecution = (
|
||||||
|
workflow: Workflow,
|
||||||
|
variables: Variable[] = [],
|
||||||
|
callbacks: VWBExecutionCallbacks = {},
|
||||||
|
options: UseVWBExecutionOptions = {}
|
||||||
|
) => {
|
||||||
|
const {
|
||||||
|
autoValidate = true,
|
||||||
|
generateEvidence = true,
|
||||||
|
retryAttempts = 3,
|
||||||
|
timeout = 30000,
|
||||||
|
pauseOnError = false,
|
||||||
|
skipNonVWBSteps = false
|
||||||
|
} = options;
|
||||||
|
|
||||||
|
// État d'exécution
|
||||||
|
const [executionState, setExecutionState] = useState<VWBExecutionState>({
|
||||||
|
status: 'idle',
|
||||||
|
currentStepIndex: 0,
|
||||||
|
currentStep: null,
|
||||||
|
totalSteps: 0,
|
||||||
|
completedSteps: 0,
|
||||||
|
failedSteps: 0,
|
||||||
|
startTime: null,
|
||||||
|
endTime: null,
|
||||||
|
duration: 0,
|
||||||
|
progress: 0,
|
||||||
|
results: [],
|
||||||
|
errors: [],
|
||||||
|
evidence: []
|
||||||
|
});
|
||||||
|
|
||||||
|
// Références pour éviter les re-renders
|
||||||
|
const executionRef = useRef<{
|
||||||
|
isRunning: boolean;
|
||||||
|
isPaused: boolean;
|
||||||
|
shouldStop: boolean;
|
||||||
|
}>({
|
||||||
|
isRunning: false,
|
||||||
|
isPaused: false,
|
||||||
|
shouldStop: false
|
||||||
|
});
|
||||||
|
|
||||||
|
// Initialiser le contexte d'exécution
|
||||||
|
useEffect(() => {
|
||||||
|
const variablesMap = variables.reduce((acc, variable) => {
|
||||||
|
acc[variable.name] = variable.value;
|
||||||
|
return acc;
|
||||||
|
}, {} as Record<string, any>);
|
||||||
|
|
||||||
|
const context: VWBExecutionContext = {
|
||||||
|
workflowId: workflow.id,
|
||||||
|
sessionId: `session_${Date.now()}`,
|
||||||
|
variables: variablesMap,
|
||||||
|
previousResults: executionState.results
|
||||||
|
};
|
||||||
|
|
||||||
|
vwbExecutionService.initializeContext(context);
|
||||||
|
}, [workflow.id, variables, executionState.results]);
|
||||||
|
|
||||||
|
// Réinitialiser l'état lors du changement de workflow
|
||||||
|
useEffect(() => {
|
||||||
|
if (executionState.status === 'idle') {
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
currentStepIndex: 0,
|
||||||
|
currentStep: null,
|
||||||
|
totalSteps: workflow.steps.length,
|
||||||
|
completedSteps: 0,
|
||||||
|
failedSteps: 0,
|
||||||
|
progress: 0,
|
||||||
|
results: [],
|
||||||
|
errors: [],
|
||||||
|
evidence: []
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
}, [workflow.id, workflow.steps.length, executionState.status]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Démarrer l'exécution du workflow
|
||||||
|
*/
|
||||||
|
const startExecution = useCallback(async () => {
|
||||||
|
console.log('🚀 [VWB] startExecution appelé', {
|
||||||
|
isRunning: executionRef.current.isRunning,
|
||||||
|
stepsLength: workflow.steps.length,
|
||||||
|
workflowId: workflow.id
|
||||||
|
});
|
||||||
|
|
||||||
|
if (executionRef.current.isRunning) {
|
||||||
|
console.log('⚠️ [VWB] Exécution déjà en cours, ignoré');
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (workflow.steps.length === 0) {
|
||||||
|
console.log('⚠️ [VWB] Aucune étape dans le workflow, ignoré');
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Réinitialiser l'état
|
||||||
|
executionRef.current = {
|
||||||
|
isRunning: true,
|
||||||
|
isPaused: false,
|
||||||
|
shouldStop: false
|
||||||
|
};
|
||||||
|
|
||||||
|
const startTime = new Date();
|
||||||
|
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
status: 'running',
|
||||||
|
startTime,
|
||||||
|
endTime: null,
|
||||||
|
currentStepIndex: 0,
|
||||||
|
currentStep: workflow.steps[0],
|
||||||
|
totalSteps: workflow.steps.length,
|
||||||
|
completedSteps: 0,
|
||||||
|
failedSteps: 0,
|
||||||
|
progress: 0,
|
||||||
|
results: [],
|
||||||
|
errors: [],
|
||||||
|
evidence: []
|
||||||
|
}));
|
||||||
|
|
||||||
|
try {
|
||||||
|
// Passer les steps directement pour éviter le problème de stale closure
|
||||||
|
await executeWorkflowSteps(workflow.steps);
|
||||||
|
} catch (error) {
|
||||||
|
console.error('Erreur lors de l\'exécution du workflow:', error);
|
||||||
|
// handleExecutionError défini plus bas, on gère l'erreur ici directement
|
||||||
|
executionRef.current.isRunning = false;
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
status: 'error',
|
||||||
|
endTime: new Date(),
|
||||||
|
errors: [...prev.errors, {
|
||||||
|
stepId: prev.currentStep?.id || 'unknown',
|
||||||
|
message: error instanceof Error ? error.message : 'Erreur inconnue',
|
||||||
|
timestamp: new Date()
|
||||||
|
}]
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
}, [workflow.steps]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Exécuter toutes les étapes du workflow
|
||||||
|
* @param steps - Les étapes à exécuter (passées directement pour éviter stale closure)
|
||||||
|
*/
|
||||||
|
const executeWorkflowSteps = useCallback(async (steps: Step[]) => {
|
||||||
|
const results: VWBExecutionResult[] = [];
|
||||||
|
const errors: ExecutionError[] = [];
|
||||||
|
const evidence: Evidence[] = [];
|
||||||
|
|
||||||
|
console.log('🔄 [VWB] executeWorkflowSteps démarré, nombre d\'étapes:', steps.length);
|
||||||
|
|
||||||
|
for (let i = 0; i < steps.length; i++) {
|
||||||
|
console.log(`📍 [VWB] Début boucle étape ${i + 1}/${steps.length}`);
|
||||||
|
|
||||||
|
// Vérifier si l'exécution doit s'arrêter
|
||||||
|
if (executionRef.current.shouldStop) {
|
||||||
|
console.log('⛔ [VWB] Arrêt demandé, sortie de la boucle');
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Attendre si en pause
|
||||||
|
while (executionRef.current.isPaused && !executionRef.current.shouldStop) {
|
||||||
|
await new Promise(resolve => setTimeout(resolve, 100));
|
||||||
|
}
|
||||||
|
|
||||||
|
const step = steps[i];
|
||||||
|
console.log(`📋 [VWB] Étape ${i + 1}:`, {
|
||||||
|
id: step.id,
|
||||||
|
type: step.type,
|
||||||
|
action_id: step.action_id,
|
||||||
|
data: step.data
|
||||||
|
});
|
||||||
|
|
||||||
|
// Mettre à jour l'état actuel
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
currentStepIndex: i,
|
||||||
|
currentStep: step,
|
||||||
|
progress: (i / steps.length) * 100
|
||||||
|
}));
|
||||||
|
|
||||||
|
// Callback de début d'étape
|
||||||
|
callbacks.onStepStart?.(step, i);
|
||||||
|
callbacks.onProgressUpdate?.(i / steps.length, step);
|
||||||
|
|
||||||
|
try {
|
||||||
|
// Vérifier si c'est une étape VWB
|
||||||
|
const isVWBStep = vwbExecutionService.isVWBStep(step);
|
||||||
|
console.log(`🔍 [VWB] Étape ${step.id} isVWBStep:`, isVWBStep);
|
||||||
|
|
||||||
|
if (!isVWBStep && skipNonVWBSteps) {
|
||||||
|
console.log(`⏭️ [VWB] Étape ${step.id} ignorée (non-VWB)`);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
let result: VWBExecutionResult;
|
||||||
|
|
||||||
|
if (isVWBStep) {
|
||||||
|
console.log(`🎯 [VWB] Exécution VWB de l'étape ${step.id}...`);
|
||||||
|
// Exécuter l'étape VWB
|
||||||
|
const executionOptions: VWBExecutionOptions = {
|
||||||
|
timeout,
|
||||||
|
retryAttempts,
|
||||||
|
validateBeforeExecution: autoValidate,
|
||||||
|
generateEvidence
|
||||||
|
};
|
||||||
|
|
||||||
|
result = await vwbExecutionService.executeStep(step, executionOptions);
|
||||||
|
console.log(`📊 [VWB] Résultat étape ${step.id}:`, result);
|
||||||
|
} else {
|
||||||
|
console.log(`🔧 [VWB] Simulation étape non-VWB ${step.id}...`);
|
||||||
|
// Simuler l'exécution pour les étapes non-VWB
|
||||||
|
result = await simulateNonVWBStep(step);
|
||||||
|
console.log(`📊 [VWB] Résultat simulation ${step.id}:`, result);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Traiter le résultat
|
||||||
|
results.push(result);
|
||||||
|
|
||||||
|
if (result.success) {
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
completedSteps: prev.completedSteps + 1
|
||||||
|
}));
|
||||||
|
|
||||||
|
// Ajouter les Evidence
|
||||||
|
if (result.evidence) {
|
||||||
|
evidence.push(...result.evidence);
|
||||||
|
callbacks.onEvidenceGenerated?.(step.id, result.evidence);
|
||||||
|
}
|
||||||
|
|
||||||
|
callbacks.onStepComplete?.(step, result);
|
||||||
|
} else {
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
failedSteps: prev.failedSteps + 1
|
||||||
|
}));
|
||||||
|
|
||||||
|
if (result.error) {
|
||||||
|
errors.push(result.error);
|
||||||
|
callbacks.onStepError?.(step, result.error);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Arrêter si configuré pour s'arrêter sur erreur
|
||||||
|
if (pauseOnError) {
|
||||||
|
executionRef.current.isPaused = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} catch (error) {
|
||||||
|
console.error(`❌ [VWB] Exception étape ${step.id}:`, error);
|
||||||
|
|
||||||
|
const executionError: ExecutionError = {
|
||||||
|
stepId: step.id,
|
||||||
|
message: error instanceof Error ? error.message : 'Erreur inconnue',
|
||||||
|
// type: 'execution_error',
|
||||||
|
timestamp: new Date(),
|
||||||
|
// context: { stepIndex: i }
|
||||||
|
};
|
||||||
|
|
||||||
|
errors.push(executionError);
|
||||||
|
callbacks.onStepError?.(step, executionError);
|
||||||
|
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
failedSteps: prev.failedSteps + 1
|
||||||
|
}));
|
||||||
|
|
||||||
|
if (pauseOnError) {
|
||||||
|
console.log('⏸️ [VWB] Pause sur erreur activée');
|
||||||
|
executionRef.current.isPaused = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
console.log(`✅ [VWB] Fin traitement étape ${i + 1}/${steps.length}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
console.log('🏁 [VWB] Boucle terminée, finalisation...');
|
||||||
|
// Finaliser l'exécution
|
||||||
|
await finalizeExecution(results, errors, evidence);
|
||||||
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||||
|
}, [callbacks, autoValidate, generateEvidence, timeout, retryAttempts, pauseOnError, skipNonVWBSteps]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Simuler l'exécution d'une étape non-VWB
|
||||||
|
*/
|
||||||
|
const simulateNonVWBStep = useCallback(async (step: Step): Promise<VWBExecutionResult> => {
|
||||||
|
// Simulation simple pour les étapes non-VWB
|
||||||
|
await new Promise(resolve => setTimeout(resolve, 500));
|
||||||
|
|
||||||
|
return {
|
||||||
|
success: true,
|
||||||
|
stepId: step.id,
|
||||||
|
actionId: step.action_id || "unknown",
|
||||||
|
duration: 500,
|
||||||
|
output: { simulated: true, stepType: step.action_id }
|
||||||
|
};
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finaliser l'exécution
|
||||||
|
*/
|
||||||
|
const finalizeExecution = useCallback(async (
|
||||||
|
results: VWBExecutionResult[],
|
||||||
|
errors: ExecutionError[],
|
||||||
|
evidence: Evidence[]
|
||||||
|
) => {
|
||||||
|
const endTime = new Date();
|
||||||
|
const duration = executionState.startTime ? endTime.getTime() - executionState.startTime.getTime() : 0;
|
||||||
|
const successRate = results.length > 0 ? (results.filter(r => r.success).length / results.length) * 100 : 0;
|
||||||
|
|
||||||
|
executionRef.current.isRunning = false;
|
||||||
|
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
status: errors.length === 0 ? 'completed' : 'error',
|
||||||
|
endTime,
|
||||||
|
duration,
|
||||||
|
progress: 100,
|
||||||
|
results,
|
||||||
|
errors,
|
||||||
|
evidence
|
||||||
|
}));
|
||||||
|
|
||||||
|
// Créer le résumé d'exécution
|
||||||
|
const summary: VWBExecutionSummary = {
|
||||||
|
totalSteps: workflow.steps.length,
|
||||||
|
completedSteps: results.filter(r => r.success).length,
|
||||||
|
failedSteps: results.filter(r => !r.success).length,
|
||||||
|
skippedSteps: workflow.steps.length - results.length,
|
||||||
|
duration,
|
||||||
|
successRate,
|
||||||
|
results,
|
||||||
|
errors,
|
||||||
|
evidence
|
||||||
|
};
|
||||||
|
|
||||||
|
callbacks.onExecutionComplete?.(errors.length === 0, summary);
|
||||||
|
}, [workflow.steps.length, executionState.startTime, callbacks]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Mettre en pause l'exécution
|
||||||
|
*/
|
||||||
|
const pauseExecution = useCallback(() => {
|
||||||
|
if (executionRef.current.isRunning && !executionRef.current.isPaused) {
|
||||||
|
executionRef.current.isPaused = true;
|
||||||
|
setExecutionState(prev => ({ ...prev, status: 'paused' }));
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Reprendre l'exécution
|
||||||
|
*/
|
||||||
|
const resumeExecution = useCallback(() => {
|
||||||
|
if (executionRef.current.isRunning && executionRef.current.isPaused) {
|
||||||
|
executionRef.current.isPaused = false;
|
||||||
|
setExecutionState(prev => ({ ...prev, status: 'running' }));
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Arrêter l'exécution
|
||||||
|
*/
|
||||||
|
const stopExecution = useCallback(() => {
|
||||||
|
executionRef.current.shouldStop = true;
|
||||||
|
executionRef.current.isPaused = false;
|
||||||
|
vwbExecutionService.cancelExecution();
|
||||||
|
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
status: 'idle',
|
||||||
|
endTime: new Date()
|
||||||
|
}));
|
||||||
|
|
||||||
|
executionRef.current.isRunning = false;
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gérer les erreurs d'exécution
|
||||||
|
*/
|
||||||
|
const handleExecutionError = useCallback((message: string) => {
|
||||||
|
executionRef.current.isRunning = false;
|
||||||
|
|
||||||
|
setExecutionState(prev => ({
|
||||||
|
...prev,
|
||||||
|
status: 'error',
|
||||||
|
endTime: new Date(),
|
||||||
|
errors: [...prev.errors, {
|
||||||
|
stepId: prev.currentStep?.id || 'unknown',
|
||||||
|
message,
|
||||||
|
// type: 'execution_error',
|
||||||
|
timestamp: new Date()
|
||||||
|
}]
|
||||||
|
}));
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Réinitialiser l'état d'exécution
|
||||||
|
*/
|
||||||
|
const resetExecution = useCallback(() => {
|
||||||
|
stopExecution();
|
||||||
|
|
||||||
|
setExecutionState({
|
||||||
|
status: 'idle',
|
||||||
|
currentStepIndex: 0,
|
||||||
|
currentStep: null,
|
||||||
|
totalSteps: workflow.steps.length,
|
||||||
|
completedSteps: 0,
|
||||||
|
failedSteps: 0,
|
||||||
|
startTime: null,
|
||||||
|
endTime: null,
|
||||||
|
duration: 0,
|
||||||
|
progress: 0,
|
||||||
|
results: [],
|
||||||
|
errors: [],
|
||||||
|
evidence: []
|
||||||
|
});
|
||||||
|
}, [workflow.steps.length, stopExecution]);
|
||||||
|
|
||||||
|
// Nettoyage lors du démontage
|
||||||
|
useEffect(() => {
|
||||||
|
return () => {
|
||||||
|
vwbExecutionService.cleanup();
|
||||||
|
};
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
return {
|
||||||
|
// État
|
||||||
|
executionState,
|
||||||
|
isRunning: executionRef.current.isRunning,
|
||||||
|
isPaused: executionRef.current.isPaused,
|
||||||
|
canStart: !executionRef.current.isRunning && workflow.steps.length > 0,
|
||||||
|
canPause: executionRef.current.isRunning && !executionRef.current.isPaused,
|
||||||
|
canResume: executionRef.current.isRunning && executionRef.current.isPaused,
|
||||||
|
canStop: executionRef.current.isRunning,
|
||||||
|
|
||||||
|
// Actions
|
||||||
|
startExecution,
|
||||||
|
pauseExecution,
|
||||||
|
resumeExecution,
|
||||||
|
stopExecution,
|
||||||
|
resetExecution,
|
||||||
|
|
||||||
|
// Utilitaires
|
||||||
|
getExecutionSummary: () => ({
|
||||||
|
totalSteps: executionState.totalSteps,
|
||||||
|
completedSteps: executionState.completedSteps,
|
||||||
|
failedSteps: executionState.failedSteps,
|
||||||
|
skippedSteps: executionState.totalSteps - executionState.results.length,
|
||||||
|
duration: executionState.duration,
|
||||||
|
successRate: executionState.results.length > 0
|
||||||
|
? (executionState.results.filter(r => r.success).length / executionState.results.length) * 100
|
||||||
|
: 0,
|
||||||
|
results: executionState.results,
|
||||||
|
errors: executionState.errors,
|
||||||
|
evidence: executionState.evidence
|
||||||
|
} as VWBExecutionSummary),
|
||||||
|
|
||||||
|
isVWBStep: (step: Step) => vwbExecutionService.isVWBStep(step),
|
||||||
|
validateStep: (step: Step) => vwbExecutionService.validateStep(step)
|
||||||
|
};
|
||||||
|
};
|
||||||
@@ -0,0 +1,444 @@
|
|||||||
|
/**
|
||||||
|
* Service d'Exécution VWB - Gestion de l'exécution des actions VisionOnly
|
||||||
|
* Auteur : Dom, Alice, Kiro - 11 janvier 2026
|
||||||
|
*
|
||||||
|
* Ce service gère l'exécution des actions VWB avec communication avec l'API catalogue,
|
||||||
|
* gestion des Evidence et feedback en temps réel.
|
||||||
|
*/
|
||||||
|
|
||||||
|
import { catalogService } from './catalogService';
|
||||||
|
import {
|
||||||
|
Step,
|
||||||
|
StepExecutionState,
|
||||||
|
ExecutionResult,
|
||||||
|
ExecutionError,
|
||||||
|
Evidence
|
||||||
|
} from '../types';
|
||||||
|
import { VWBCatalogAction } from '../types/catalog';
|
||||||
|
|
||||||
|
interface VWBActionValidationResult {
|
||||||
|
is_valid: boolean;
|
||||||
|
errors: Array<{
|
||||||
|
field: string;
|
||||||
|
message: string;
|
||||||
|
severity: 'error' | 'warning';
|
||||||
|
}>;
|
||||||
|
warnings?: Array<{
|
||||||
|
field: string;
|
||||||
|
message: string;
|
||||||
|
}>;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface VWBExecutionResult {
|
||||||
|
success: boolean;
|
||||||
|
stepId: string;
|
||||||
|
actionId: string;
|
||||||
|
duration: number;
|
||||||
|
evidence?: Evidence[];
|
||||||
|
error?: ExecutionError;
|
||||||
|
output?: any;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface VWBExecutionOptions {
|
||||||
|
timeout?: number;
|
||||||
|
retryAttempts?: number;
|
||||||
|
validateBeforeExecution?: boolean;
|
||||||
|
generateEvidence?: boolean;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface VWBExecutionContext {
|
||||||
|
workflowId: string;
|
||||||
|
sessionId: string;
|
||||||
|
variables: Record<string, any>;
|
||||||
|
previousResults: VWBExecutionResult[];
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Service principal pour l'exécution des actions VWB
|
||||||
|
*/
|
||||||
|
export class VWBExecutionService {
|
||||||
|
private static instance: VWBExecutionService;
|
||||||
|
private executionContext: VWBExecutionContext | null = null;
|
||||||
|
private isExecuting = false;
|
||||||
|
private currentExecution: AbortController | null = null;
|
||||||
|
|
||||||
|
private constructor() {}
|
||||||
|
|
||||||
|
public static getInstance(): VWBExecutionService {
|
||||||
|
if (!VWBExecutionService.instance) {
|
||||||
|
VWBExecutionService.instance = new VWBExecutionService();
|
||||||
|
}
|
||||||
|
return VWBExecutionService.instance;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initialiser le contexte d'exécution
|
||||||
|
*/
|
||||||
|
public initializeContext(context: VWBExecutionContext): void {
|
||||||
|
this.executionContext = context;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Liste des types d'actions VWB connus du catalogue
|
||||||
|
private static readonly VWB_ACTION_TYPES = new Set([
|
||||||
|
// Interactions visuelles
|
||||||
|
'click_anchor',
|
||||||
|
'double_click_anchor',
|
||||||
|
'right_click_anchor',
|
||||||
|
'hover_anchor',
|
||||||
|
'type_text',
|
||||||
|
'type_secret',
|
||||||
|
'focus_anchor',
|
||||||
|
'drag_drop_anchor',
|
||||||
|
'scroll_to_anchor',
|
||||||
|
'keyboard_shortcut',
|
||||||
|
// Contrôle de flux
|
||||||
|
'wait_for_anchor',
|
||||||
|
'visual_condition',
|
||||||
|
'loop_visual',
|
||||||
|
// Extraction de données
|
||||||
|
'extract_text',
|
||||||
|
'extract_table',
|
||||||
|
'screenshot_evidence',
|
||||||
|
'download_to_folder',
|
||||||
|
// Intelligence IA
|
||||||
|
'ai_analyze_text',
|
||||||
|
// Base de données
|
||||||
|
'db_save_data',
|
||||||
|
'db_read_data',
|
||||||
|
// Validation
|
||||||
|
'verify_element_exists',
|
||||||
|
'verify_text_content',
|
||||||
|
]);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Vérifier si une étape est une action VWB
|
||||||
|
*/
|
||||||
|
public isVWBStep(step: Step): boolean {
|
||||||
|
// Vérifier d'abord si le type est dans la liste des actions VWB connues
|
||||||
|
const stepType = step.type || step.data?.stepType;
|
||||||
|
if (stepType && VWBExecutionService.VWB_ACTION_TYPES.has(stepType)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Vérification par marqueurs explicites
|
||||||
|
return Boolean(
|
||||||
|
step.data?.isVWBCatalogAction ||
|
||||||
|
step.data?.vwbActionId ||
|
||||||
|
step.action_id?.startsWith('vwb_') ||
|
||||||
|
step.action_id?.includes('catalog_')
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Valider une étape VWB avant exécution
|
||||||
|
*/
|
||||||
|
public async validateStep(step: Step): Promise<VWBActionValidationResult> {
|
||||||
|
if (!this.isVWBStep(step)) {
|
||||||
|
throw new Error(`L'étape ${step.id} n'est pas une action VWB`);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Extraire le type d'action depuis plusieurs sources possibles
|
||||||
|
const actionId = step.type || step.data?.stepType || step.data?.vwbActionId || step.action_id || "unknown";
|
||||||
|
const parameters = step.data?.parameters || {};
|
||||||
|
|
||||||
|
try {
|
||||||
|
const validationResult = await catalogService.validateAction({
|
||||||
|
type: actionId,
|
||||||
|
parameters
|
||||||
|
});
|
||||||
|
|
||||||
|
// Vérifier que validationResult est défini
|
||||||
|
if (!validationResult) {
|
||||||
|
// Si pas de résultat, considérer comme valide (pas de validation côté serveur)
|
||||||
|
return {
|
||||||
|
is_valid: true,
|
||||||
|
errors: [],
|
||||||
|
warnings: [],
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// Convertir vers le format VWB
|
||||||
|
return {
|
||||||
|
is_valid: validationResult.is_valid ?? true,
|
||||||
|
errors: (validationResult.errors || []).map(error => ({
|
||||||
|
field: 'unknown',
|
||||||
|
message: typeof error === 'string' ? error : error.message || 'Erreur de validation',
|
||||||
|
severity: 'error' as const,
|
||||||
|
})),
|
||||||
|
warnings: (validationResult.warnings || []).map(warning => ({
|
||||||
|
field: 'unknown',
|
||||||
|
message: typeof warning === 'string' ? warning : warning.message || 'Avertissement',
|
||||||
|
})),
|
||||||
|
};
|
||||||
|
} catch (error) {
|
||||||
|
console.error('Erreur lors de la validation VWB:', error);
|
||||||
|
// En cas d'erreur de validation (ex: API non disponible), permettre l'exécution
|
||||||
|
return {
|
||||||
|
is_valid: true,
|
||||||
|
errors: [],
|
||||||
|
warnings: [{
|
||||||
|
field: 'validation',
|
||||||
|
message: `Validation non disponible: ${error instanceof Error ? error.message : 'Erreur inconnue'}`,
|
||||||
|
}],
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Exécuter une étape VWB
|
||||||
|
*/
|
||||||
|
public async executeStep(
|
||||||
|
step: Step,
|
||||||
|
options: VWBExecutionOptions = {}
|
||||||
|
): Promise<VWBExecutionResult> {
|
||||||
|
const startTime = Date.now();
|
||||||
|
const {
|
||||||
|
timeout = 30000,
|
||||||
|
retryAttempts = 3,
|
||||||
|
validateBeforeExecution = true,
|
||||||
|
generateEvidence = true
|
||||||
|
} = options;
|
||||||
|
|
||||||
|
if (!this.isVWBStep(step)) {
|
||||||
|
throw new Error(`L'étape ${step.id} n'est pas une action VWB`);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Créer un contrôleur d'annulation
|
||||||
|
this.currentExecution = new AbortController();
|
||||||
|
this.isExecuting = true;
|
||||||
|
|
||||||
|
try {
|
||||||
|
// Validation préalable si demandée
|
||||||
|
if (validateBeforeExecution) {
|
||||||
|
const validation = await this.validateStep(step);
|
||||||
|
if (!validation.is_valid) {
|
||||||
|
const errorMessages = validation.errors.map(e => e.message).join(', ');
|
||||||
|
throw new Error(`Validation échouée: ${errorMessages}`);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Extraire le type d'action depuis plusieurs sources possibles
|
||||||
|
const actionId = step.type || step.data?.stepType || step.data?.vwbActionId || step.action_id || "unknown";
|
||||||
|
const parameters = this.prepareParameters(step);
|
||||||
|
|
||||||
|
// Exécuter l'action avec retry
|
||||||
|
let lastError: Error | null = null;
|
||||||
|
for (let attempt = 1; attempt <= retryAttempts; attempt++) {
|
||||||
|
try {
|
||||||
|
const result = await this.executeActionWithTimeout(
|
||||||
|
actionId,
|
||||||
|
parameters,
|
||||||
|
timeout,
|
||||||
|
this.currentExecution.signal
|
||||||
|
);
|
||||||
|
|
||||||
|
const duration = Date.now() - startTime;
|
||||||
|
|
||||||
|
// Traiter les Evidence si disponibles
|
||||||
|
const evidence = generateEvidence ? await this.processEvidence(result, startTime) : undefined;
|
||||||
|
|
||||||
|
return {
|
||||||
|
success: true,
|
||||||
|
stepId: step.id,
|
||||||
|
actionId: actionId,
|
||||||
|
duration,
|
||||||
|
evidence,
|
||||||
|
output: result
|
||||||
|
};
|
||||||
|
|
||||||
|
} catch (error) {
|
||||||
|
lastError = error instanceof Error ? error : new Error('Erreur inconnue');
|
||||||
|
|
||||||
|
if (this.currentExecution.signal.aborted) {
|
||||||
|
throw new Error('Exécution annulée par l\'utilisateur');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (attempt < retryAttempts) {
|
||||||
|
console.warn(`Tentative ${attempt} échouée pour ${actionId}, retry...`);
|
||||||
|
await this.delay(1000 * attempt); // Backoff exponentiel
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Toutes les tentatives ont échoué
|
||||||
|
throw lastError || new Error('Échec après toutes les tentatives');
|
||||||
|
|
||||||
|
} catch (error) {
|
||||||
|
const duration = Date.now() - startTime;
|
||||||
|
const executionError: ExecutionError = {
|
||||||
|
stepId: step.id,
|
||||||
|
message: error instanceof Error ? error.message : 'Erreur inconnue',
|
||||||
|
timestamp: new Date(),
|
||||||
|
};
|
||||||
|
|
||||||
|
return {
|
||||||
|
success: false,
|
||||||
|
stepId: step.id,
|
||||||
|
actionId: step.type || step.data?.stepType || step.data?.vwbActionId || step.action_id || "unknown",
|
||||||
|
duration,
|
||||||
|
error: executionError
|
||||||
|
};
|
||||||
|
|
||||||
|
} finally {
|
||||||
|
this.isExecuting = false;
|
||||||
|
this.currentExecution = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Exécuter une action avec timeout
|
||||||
|
*/
|
||||||
|
private async executeActionWithTimeout(
|
||||||
|
actionId: string,
|
||||||
|
parameters: Record<string, any>,
|
||||||
|
timeout: number,
|
||||||
|
signal: AbortSignal
|
||||||
|
): Promise<any> {
|
||||||
|
const timeoutPromise = new Promise((_, reject) => {
|
||||||
|
const timeoutId = setTimeout(() => {
|
||||||
|
reject(new Error(`Timeout après ${timeout}ms`));
|
||||||
|
}, timeout);
|
||||||
|
|
||||||
|
signal.addEventListener('abort', () => {
|
||||||
|
clearTimeout(timeoutId);
|
||||||
|
reject(new Error('Exécution annulée'));
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
const executionPromise = catalogService.executeAction({
|
||||||
|
type: actionId,
|
||||||
|
parameters
|
||||||
|
});
|
||||||
|
|
||||||
|
return Promise.race([executionPromise, timeoutPromise]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Préparer les paramètres pour l'exécution
|
||||||
|
*/
|
||||||
|
private prepareParameters(step: Step): Record<string, any> {
|
||||||
|
let parameters = { ...step.data?.parameters || {} };
|
||||||
|
|
||||||
|
// Résoudre les variables si contexte disponible
|
||||||
|
if (this.executionContext?.variables) {
|
||||||
|
parameters = this.resolveVariables(parameters, this.executionContext.variables);
|
||||||
|
}
|
||||||
|
|
||||||
|
return parameters;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Résoudre les variables dans les paramètres
|
||||||
|
*/
|
||||||
|
private resolveVariables(
|
||||||
|
parameters: Record<string, any>,
|
||||||
|
variables: Record<string, any>
|
||||||
|
): Record<string, any> {
|
||||||
|
const resolved = { ...parameters };
|
||||||
|
|
||||||
|
for (const [key, value] of Object.entries(resolved)) {
|
||||||
|
if (typeof value === 'string' && value.includes('${')) {
|
||||||
|
// Remplacer les variables ${variableName}
|
||||||
|
resolved[key] = value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
|
||||||
|
return variables[varName] !== undefined ? variables[varName] : match;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return resolved;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Traiter les Evidence de l'exécution
|
||||||
|
*/
|
||||||
|
private async processEvidence(result: any, executionStartTime: number): Promise<Evidence[]> {
|
||||||
|
const evidence: Evidence[] = [];
|
||||||
|
|
||||||
|
if (result?.evidence) {
|
||||||
|
// Si l'API retourne des Evidence directement
|
||||||
|
if (Array.isArray(result.evidence)) {
|
||||||
|
evidence.push(...result.evidence);
|
||||||
|
} else {
|
||||||
|
evidence.push(result.evidence);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Créer une Evidence de base si aucune n'est fournie
|
||||||
|
if (evidence.length === 0 && result?.success) {
|
||||||
|
evidence.push({
|
||||||
|
contract: 'vwb_evidence',
|
||||||
|
version: '1.0',
|
||||||
|
id: `evidence_${Date.now()}`,
|
||||||
|
action_id: 'execution_success',
|
||||||
|
captured_at: new Date().toISOString(),
|
||||||
|
screenshot_base64: '',
|
||||||
|
execution_time_ms: Date.now() - executionStartTime,
|
||||||
|
success: true,
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
data: {
|
||||||
|
result: result,
|
||||||
|
message: 'Action exécutée avec succès'
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
return evidence;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Annuler l'exécution en cours
|
||||||
|
*/
|
||||||
|
public cancelExecution(): void {
|
||||||
|
if (this.currentExecution) {
|
||||||
|
this.currentExecution.abort();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Vérifier si une exécution est en cours
|
||||||
|
*/
|
||||||
|
public isExecutionRunning(): boolean {
|
||||||
|
return this.isExecuting;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Obtenir le contexte d'exécution actuel
|
||||||
|
*/
|
||||||
|
public getExecutionContext(): VWBExecutionContext | null {
|
||||||
|
return this.executionContext;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Nettoyer le contexte d'exécution
|
||||||
|
*/
|
||||||
|
public cleanup(): void {
|
||||||
|
this.cancelExecution();
|
||||||
|
this.executionContext = null;
|
||||||
|
this.isExecuting = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Utilitaire pour attendre
|
||||||
|
*/
|
||||||
|
private delay(ms: number): Promise<void> {
|
||||||
|
return new Promise(resolve => setTimeout(resolve, ms));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Instance singleton
|
||||||
|
export const vwbExecutionService = VWBExecutionService.getInstance();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Hook pour utiliser le service d'exécution VWB
|
||||||
|
*/
|
||||||
|
export const useVWBExecutionService = () => {
|
||||||
|
return {
|
||||||
|
service: vwbExecutionService,
|
||||||
|
isVWBStep: (step: Step) => vwbExecutionService.isVWBStep(step),
|
||||||
|
executeStep: (step: Step, options?: VWBExecutionOptions) =>
|
||||||
|
vwbExecutionService.executeStep(step, options),
|
||||||
|
validateStep: (step: Step) => vwbExecutionService.validateStep(step),
|
||||||
|
cancelExecution: () => vwbExecutionService.cancelExecution(),
|
||||||
|
isExecutionRunning: () => vwbExecutionService.isExecutionRunning(),
|
||||||
|
};
|
||||||
|
};
|
||||||
Reference in New Issue
Block a user