1264 lines
41 KiB
JavaScript
1264 lines
41 KiB
JavaScript
// ========================================
|
|
// FICHIER: ManualServer.js
|
|
// RESPONSABILITÉ: Mode MANUAL - Interface Client + API + WebSocket
|
|
// FONCTIONNALITÉS: Dashboard, tests modulaires, API complète
|
|
// ========================================
|
|
|
|
const express = require('express');
|
|
const cors = require('cors');
|
|
const path = require('path');
|
|
const WebSocket = require('ws');
|
|
|
|
const { logSh } = require('../ErrorReporting');
|
|
const { handleModularWorkflow, benchmarkStacks } = require('../main_modulaire');
|
|
|
|
/**
|
|
* SERVEUR MODE MANUAL
|
|
* Interface client complète avec API, WebSocket et dashboard
|
|
*/
|
|
class ManualServer {
|
|
|
|
constructor(options = {}) {
|
|
this.config = {
|
|
port: options.port || process.env.MANUAL_PORT || 3000,
|
|
wsPort: options.wsPort || process.env.WS_PORT || 8081,
|
|
host: options.host || '0.0.0.0',
|
|
...options
|
|
};
|
|
|
|
this.app = null;
|
|
this.server = null;
|
|
this.wsServer = null;
|
|
this.activeClients = new Set();
|
|
this.stats = {
|
|
sessions: 0,
|
|
requests: 0,
|
|
testsExecuted: 0,
|
|
startTime: Date.now(),
|
|
lastActivity: null
|
|
};
|
|
|
|
this.isRunning = false;
|
|
}
|
|
|
|
// ========================================
|
|
// DÉMARRAGE ET ARRÊT
|
|
// ========================================
|
|
|
|
/**
|
|
* Démarre le serveur MANUAL complet
|
|
*/
|
|
async start() {
|
|
if (this.isRunning) {
|
|
logSh('⚠️ ManualServer déjà en cours d\'exécution', 'WARNING');
|
|
return;
|
|
}
|
|
|
|
logSh('🎯 Démarrage ManualServer...', 'INFO');
|
|
|
|
try {
|
|
// 1. Configuration Express
|
|
await this.setupExpressApp();
|
|
|
|
// 2. Routes API
|
|
this.setupAPIRoutes();
|
|
|
|
// 3. Interface Web
|
|
this.setupWebInterface();
|
|
|
|
// 4. WebSocket pour logs temps réel
|
|
await this.setupWebSocketServer();
|
|
|
|
// 5. Démarrage serveur HTTP
|
|
await this.startHTTPServer();
|
|
|
|
// 6. Monitoring
|
|
this.startMonitoring();
|
|
|
|
this.isRunning = true;
|
|
this.stats.startTime = Date.now();
|
|
|
|
logSh(`✅ ManualServer démarré sur http://localhost:${this.config.port}`, 'INFO');
|
|
logSh(`📡 WebSocket logs sur ws://localhost:${this.config.wsPort}`, 'INFO');
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur démarrage ManualServer: ${error.message}`, 'ERROR');
|
|
await this.stop();
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Arrête le serveur MANUAL
|
|
*/
|
|
async stop() {
|
|
if (!this.isRunning) return;
|
|
|
|
logSh('🛑 Arrêt ManualServer...', 'INFO');
|
|
|
|
try {
|
|
// Déconnecter tous les clients WebSocket
|
|
this.disconnectAllClients();
|
|
|
|
// Arrêter WebSocket server
|
|
if (this.wsServer) {
|
|
this.wsServer.close();
|
|
this.wsServer = null;
|
|
}
|
|
|
|
// Arrêter serveur HTTP
|
|
if (this.server) {
|
|
await new Promise((resolve) => {
|
|
this.server.close(() => resolve());
|
|
});
|
|
this.server = null;
|
|
}
|
|
|
|
this.isRunning = false;
|
|
|
|
logSh('✅ ManualServer arrêté', 'INFO');
|
|
|
|
} catch (error) {
|
|
logSh(`⚠️ Erreur arrêt ManualServer: ${error.message}`, 'WARNING');
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// CONFIGURATION EXPRESS
|
|
// ========================================
|
|
|
|
/**
|
|
* Configure l'application Express
|
|
*/
|
|
async setupExpressApp() {
|
|
this.app = express();
|
|
|
|
// Middleware de base
|
|
this.app.use(express.json({ limit: '10mb' }));
|
|
this.app.use(express.urlencoded({ extended: true }));
|
|
this.app.use(cors());
|
|
|
|
// Middleware de logs des requêtes
|
|
this.app.use((req, res, next) => {
|
|
this.stats.requests++;
|
|
this.stats.lastActivity = Date.now();
|
|
|
|
logSh(`📥 ${req.method} ${req.path} - ${req.ip}`, 'TRACE');
|
|
next();
|
|
});
|
|
|
|
// Fichiers statiques
|
|
this.app.use(express.static(path.join(__dirname, '../../public')));
|
|
|
|
// Route spécifique pour l'interface step-by-step
|
|
this.app.get('/step-by-step', (req, res) => {
|
|
res.sendFile(path.join(__dirname, '../../public/step-by-step.html'));
|
|
});
|
|
|
|
logSh('⚙️ Express configuré', 'DEBUG');
|
|
}
|
|
|
|
/**
|
|
* Configure les routes API
|
|
*/
|
|
setupAPIRoutes() {
|
|
// Route de status
|
|
this.app.get('/api/status', (req, res) => {
|
|
res.json({
|
|
success: true,
|
|
mode: 'MANUAL',
|
|
status: 'running',
|
|
uptime: Date.now() - this.stats.startTime,
|
|
stats: { ...this.stats },
|
|
clients: this.activeClients.size,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
});
|
|
|
|
// Test modulaire individuel
|
|
this.app.post('/api/test-modulaire', async (req, res) => {
|
|
await this.handleTestModulaire(req, res);
|
|
});
|
|
|
|
// 🆕 Workflow modulaire avec sauvegarde par étapes
|
|
this.app.post('/api/workflow-modulaire', async (req, res) => {
|
|
await this.handleWorkflowModulaire(req, res);
|
|
});
|
|
|
|
// Benchmark modulaire complet
|
|
this.app.post('/api/benchmark-modulaire', async (req, res) => {
|
|
await this.handleBenchmarkModulaire(req, res);
|
|
});
|
|
|
|
// Configuration modulaire disponible
|
|
this.app.get('/api/modulaire-config', (req, res) => {
|
|
this.handleModulaireConfig(req, res);
|
|
});
|
|
|
|
// Stats détaillées
|
|
this.app.get('/api/stats', (req, res) => {
|
|
res.json({
|
|
success: true,
|
|
stats: {
|
|
...this.stats,
|
|
uptime: Date.now() - this.stats.startTime,
|
|
activeClients: this.activeClients.size,
|
|
memory: process.memoryUsage(),
|
|
timestamp: new Date().toISOString()
|
|
}
|
|
});
|
|
});
|
|
|
|
// Lancer le log viewer avec WebSocket
|
|
this.app.post('/api/start-log-viewer', (req, res) => {
|
|
this.handleStartLogViewer(req, res);
|
|
});
|
|
|
|
// ========================================
|
|
// APIs STEP-BY-STEP
|
|
// ========================================
|
|
|
|
// Initialiser une session step-by-step
|
|
this.app.post('/api/step-by-step/init', async (req, res) => {
|
|
await this.handleStepByStepInit(req, res);
|
|
});
|
|
|
|
// Exécuter une étape
|
|
this.app.post('/api/step-by-step/execute', async (req, res) => {
|
|
await this.handleStepByStepExecute(req, res);
|
|
});
|
|
|
|
// Status d'une session
|
|
this.app.get('/api/step-by-step/status/:sessionId', (req, res) => {
|
|
this.handleStepByStepStatus(req, res);
|
|
});
|
|
|
|
// Reset une session
|
|
this.app.post('/api/step-by-step/reset', (req, res) => {
|
|
this.handleStepByStepReset(req, res);
|
|
});
|
|
|
|
// Export résultats
|
|
this.app.get('/api/step-by-step/export/:sessionId', (req, res) => {
|
|
this.handleStepByStepExport(req, res);
|
|
});
|
|
|
|
// Liste des sessions actives
|
|
this.app.get('/api/step-by-step/sessions', (req, res) => {
|
|
this.handleStepByStepSessions(req, res);
|
|
});
|
|
|
|
// API pour récupérer les personnalités
|
|
this.app.get('/api/personalities', async (req, res) => {
|
|
await this.handleGetPersonalities(req, res);
|
|
});
|
|
|
|
// Gestion d'erreurs API
|
|
this.app.use('/api/*', (error, req, res, next) => {
|
|
logSh(`❌ Erreur API ${req.path}: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur serveur interne',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
});
|
|
|
|
logSh('🛠️ Routes API configurées', 'DEBUG');
|
|
}
|
|
|
|
// ========================================
|
|
// HANDLERS API
|
|
// ========================================
|
|
|
|
/**
|
|
* Gère les tests modulaires individuels
|
|
*/
|
|
async handleTestModulaire(req, res) {
|
|
try {
|
|
const config = req.body;
|
|
this.stats.testsExecuted++;
|
|
|
|
logSh(`🧪 Test modulaire: ${config.selectiveStack} + ${config.adversarialMode} + ${config.humanSimulationMode} + ${config.patternBreakingMode}`, 'INFO');
|
|
|
|
// Validation des paramètres
|
|
if (!config.rowNumber || config.rowNumber < 2) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Numéro de ligne invalide (minimum 2)'
|
|
});
|
|
}
|
|
|
|
// Exécution du test
|
|
const result = await handleModularWorkflow({
|
|
...config,
|
|
source: 'manual_server_api'
|
|
});
|
|
|
|
logSh(`✅ Test modulaire terminé: ${result.stats.totalDuration}ms`, 'INFO');
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Test modulaire terminé avec succès',
|
|
stats: result.stats,
|
|
config: config,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur test modulaire: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
config: req.body,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gère les benchmarks modulaires
|
|
*/
|
|
async handleBenchmarkModulaire(req, res) {
|
|
try {
|
|
const { rowNumber = 2 } = req.body;
|
|
|
|
logSh(`📊 Benchmark modulaire ligne ${rowNumber}...`, 'INFO');
|
|
|
|
if (rowNumber < 2) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Numéro de ligne invalide (minimum 2)'
|
|
});
|
|
}
|
|
|
|
const benchResults = await benchmarkStacks(rowNumber);
|
|
|
|
const successfulTests = benchResults.filter(r => r.success);
|
|
const avgDuration = successfulTests.length > 0 ?
|
|
successfulTests.reduce((sum, r) => sum + r.duration, 0) / successfulTests.length : 0;
|
|
|
|
this.stats.testsExecuted += benchResults.length;
|
|
|
|
logSh(`📊 Benchmark terminé: ${successfulTests.length}/${benchResults.length} tests réussis`, 'INFO');
|
|
|
|
res.json({
|
|
success: true,
|
|
message: `Benchmark terminé: ${successfulTests.length}/${benchResults.length} tests réussis`,
|
|
summary: {
|
|
totalTests: benchResults.length,
|
|
successfulTests: successfulTests.length,
|
|
failedTests: benchResults.length - successfulTests.length,
|
|
averageDuration: Math.round(avgDuration),
|
|
rowNumber: rowNumber
|
|
},
|
|
results: benchResults,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur benchmark modulaire: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 🆕 Gère les workflows modulaires avec sauvegarde par étapes
|
|
*/
|
|
async handleWorkflowModulaire(req, res) {
|
|
try {
|
|
const config = req.body;
|
|
this.stats.testsExecuted++;
|
|
|
|
// Configuration par défaut avec sauvegarde activée
|
|
const workflowConfig = {
|
|
rowNumber: config.rowNumber || 2,
|
|
selectiveStack: config.selectiveStack || 'standardEnhancement',
|
|
adversarialMode: config.adversarialMode || 'light',
|
|
humanSimulationMode: config.humanSimulationMode || 'none',
|
|
patternBreakingMode: config.patternBreakingMode || 'none',
|
|
saveIntermediateSteps: config.saveIntermediateSteps !== false, // Par défaut true
|
|
source: 'api_manual_server'
|
|
};
|
|
|
|
logSh(`🔗 Workflow modulaire avec étapes: ligne ${workflowConfig.rowNumber}`, 'INFO');
|
|
logSh(` 📋 Config: ${workflowConfig.selectiveStack} + ${workflowConfig.adversarialMode} + ${workflowConfig.humanSimulationMode} + ${workflowConfig.patternBreakingMode}`, 'DEBUG');
|
|
logSh(` 💾 Sauvegarde étapes: ${workflowConfig.saveIntermediateSteps ? 'ACTIVÉE' : 'DÉSACTIVÉE'}`, 'INFO');
|
|
|
|
// Validation des paramètres
|
|
if (workflowConfig.rowNumber < 2) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Numéro de ligne invalide (minimum 2)'
|
|
});
|
|
}
|
|
|
|
// Exécution du workflow complet
|
|
const startTime = Date.now();
|
|
const result = await handleModularWorkflow(workflowConfig);
|
|
const duration = Date.now() - startTime;
|
|
|
|
// Statistiques finales
|
|
const finalStats = {
|
|
duration,
|
|
success: result.success,
|
|
versionsCreated: result.stats?.versionHistory?.length || 1,
|
|
parentArticleId: result.stats?.parentArticleId,
|
|
finalArticleId: result.storageResult?.articleId,
|
|
totalModifications: {
|
|
selective: result.stats?.selectiveEnhancements || 0,
|
|
adversarial: result.stats?.adversarialModifications || 0,
|
|
human: result.stats?.humanSimulationModifications || 0,
|
|
pattern: result.stats?.patternBreakingModifications || 0
|
|
},
|
|
finalLength: result.stats?.finalLength || 0
|
|
};
|
|
|
|
logSh(`✅ Workflow modulaire terminé: ${finalStats.versionsCreated} versions créées en ${duration}ms`, 'INFO');
|
|
|
|
res.json({
|
|
success: true,
|
|
message: `Workflow modulaire terminé avec succès (${finalStats.versionsCreated} versions sauvegardées)`,
|
|
config: workflowConfig,
|
|
stats: finalStats,
|
|
versionHistory: result.stats?.versionHistory,
|
|
result: {
|
|
parentArticleId: finalStats.parentArticleId,
|
|
finalArticleId: finalStats.finalArticleId,
|
|
duration: finalStats.duration,
|
|
modificationsCount: Object.values(finalStats.totalModifications).reduce((sum, val) => sum + val, 0),
|
|
finalWordCount: result.storageResult?.wordCount,
|
|
personality: result.stats?.personality
|
|
},
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur workflow modulaire: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retourne la configuration modulaire
|
|
*/
|
|
handleModulaireConfig(req, res) {
|
|
try {
|
|
const config = {
|
|
selectiveStacks: [
|
|
{ value: 'lightEnhancement', name: 'Light Enhancement', description: 'Améliorations légères' },
|
|
{ value: 'standardEnhancement', name: 'Standard Enhancement', description: 'Améliorations standard' },
|
|
{ value: 'fullEnhancement', name: 'Full Enhancement', description: 'Améliorations complètes' },
|
|
{ value: 'personalityFocus', name: 'Personality Focus', description: 'Focus personnalité' },
|
|
{ value: 'fluidityFocus', name: 'Fluidity Focus', description: 'Focus fluidité' },
|
|
{ value: 'adaptive', name: 'Adaptive', description: 'Adaptation automatique' }
|
|
],
|
|
adversarialModes: [
|
|
{ value: 'none', name: 'None', description: 'Aucune technique adversariale' },
|
|
{ value: 'light', name: 'Light', description: 'Techniques adversariales légères' },
|
|
{ value: 'standard', name: 'Standard', description: 'Techniques adversariales standard' },
|
|
{ value: 'heavy', name: 'Heavy', description: 'Techniques adversariales intensives' },
|
|
{ value: 'adaptive', name: 'Adaptive', description: 'Adaptation automatique' }
|
|
],
|
|
humanSimulationModes: [
|
|
{ value: 'none', name: 'None', description: 'Aucune simulation humaine' },
|
|
{ value: 'lightSimulation', name: 'Light Simulation', description: 'Simulation légère' },
|
|
{ value: 'standardSimulation', name: 'Standard Simulation', description: 'Simulation standard' },
|
|
{ value: 'heavySimulation', name: 'Heavy Simulation', description: 'Simulation intensive' },
|
|
{ value: 'adaptiveSimulation', name: 'Adaptive Simulation', description: 'Simulation adaptative' },
|
|
{ value: 'personalityFocus', name: 'Personality Focus', description: 'Focus personnalité' },
|
|
{ value: 'temporalFocus', name: 'Temporal Focus', description: 'Focus temporel' }
|
|
],
|
|
patternBreakingModes: [
|
|
{ value: 'none', name: 'None', description: 'Aucun pattern breaking' },
|
|
{ value: 'lightPatternBreaking', name: 'Light Pattern Breaking', description: 'Pattern breaking léger' },
|
|
{ value: 'standardPatternBreaking', name: 'Standard Pattern Breaking', description: 'Pattern breaking standard' },
|
|
{ value: 'heavyPatternBreaking', name: 'Heavy Pattern Breaking', description: 'Pattern breaking intensif' },
|
|
{ value: 'adaptivePatternBreaking', name: 'Adaptive Pattern Breaking', description: 'Pattern breaking adaptatif' },
|
|
{ value: 'syntaxFocus', name: 'Syntax Focus', description: 'Focus syntaxe uniquement' },
|
|
{ value: 'connectorsFocus', name: 'Connectors Focus', description: 'Focus connecteurs uniquement' }
|
|
]
|
|
};
|
|
|
|
res.json({
|
|
success: true,
|
|
config: config,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur config modulaire: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lance le log viewer avec WebSocket
|
|
*/
|
|
handleStartLogViewer(req, res) {
|
|
try {
|
|
const { spawn } = require('child_process');
|
|
const path = require('path');
|
|
const os = require('os');
|
|
|
|
// Démarrer le WebSocket pour logs
|
|
process.env.ENABLE_LOG_WS = 'true';
|
|
const { initWebSocketServer } = require('../ErrorReporting');
|
|
initWebSocketServer();
|
|
|
|
// Servir le log viewer via une route HTTP au lieu d'un fichier local
|
|
const logViewerUrl = `http://localhost:${this.config.port}/logs-viewer.html`;
|
|
|
|
// Ouvrir dans le navigateur selon l'OS
|
|
let command, args;
|
|
switch (os.platform()) {
|
|
case 'darwin': // macOS
|
|
command = 'open';
|
|
args = [logViewerUrl];
|
|
break;
|
|
case 'win32': // Windows
|
|
command = 'cmd';
|
|
args = ['/c', 'start', logViewerUrl];
|
|
break;
|
|
default: // Linux et WSL
|
|
// Pour WSL, utiliser explorer.exe de Windows
|
|
if (process.env.WSL_DISTRO_NAME) {
|
|
command = '/mnt/c/Windows/System32/cmd.exe';
|
|
args = ['/c', 'start', logViewerUrl];
|
|
} else {
|
|
command = 'xdg-open';
|
|
args = [logViewerUrl];
|
|
}
|
|
break;
|
|
}
|
|
|
|
spawn(command, args, { detached: true, stdio: 'ignore' });
|
|
|
|
const logPort = process.env.LOG_WS_PORT || 8082;
|
|
logSh(`🌐 Log viewer lancé avec WebSocket sur port ${logPort}`, 'INFO');
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Log viewer lancé',
|
|
wsPort: logPort,
|
|
viewerUrl: logViewerUrl,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur lancement log viewer: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur lancement log viewer',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// HANDLERS STEP-BY-STEP
|
|
// ========================================
|
|
|
|
/**
|
|
* Initialise une nouvelle session step-by-step
|
|
*/
|
|
async handleStepByStepInit(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
|
|
const inputData = req.body;
|
|
logSh(`🎯 Initialisation session step-by-step`, 'INFO');
|
|
logSh(` Input: ${JSON.stringify(inputData)}`, 'DEBUG');
|
|
|
|
const session = sessionManager.createSession(inputData);
|
|
|
|
res.json({
|
|
success: true,
|
|
sessionId: session.id,
|
|
steps: session.steps.map(step => ({
|
|
id: step.id,
|
|
system: step.system,
|
|
name: step.name,
|
|
description: step.description,
|
|
status: step.status
|
|
})),
|
|
inputData: session.inputData,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur init step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur initialisation session',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Exécute une étape
|
|
*/
|
|
async handleStepByStepExecute(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
const { StepExecutor } = require('../StepExecutor');
|
|
|
|
const { sessionId, stepId, options = {} } = req.body;
|
|
|
|
if (!sessionId || !stepId) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'sessionId et stepId requis',
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
|
|
logSh(`🚀 Exécution étape ${stepId} pour session ${sessionId}`, 'INFO');
|
|
|
|
// Récupérer la session
|
|
const session = sessionManager.getSession(sessionId);
|
|
|
|
// Trouver l'étape
|
|
const step = session.steps.find(s => s.id === stepId);
|
|
if (!step) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: `Étape ${stepId} introuvable`,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
|
|
// Marquer l'étape comme en cours
|
|
step.status = 'executing';
|
|
|
|
// Créer l'exécuteur et lancer l'étape
|
|
const executor = new StepExecutor();
|
|
const result = await executor.executeStep(step.system, session.inputData, options);
|
|
|
|
// Ajouter le résultat à la session
|
|
sessionManager.addStepResult(sessionId, stepId, result);
|
|
|
|
// Déterminer la prochaine étape
|
|
const nextStep = session.steps.find(s => s.id === stepId + 1);
|
|
|
|
res.json({
|
|
success: true,
|
|
stepId: stepId,
|
|
system: step.system,
|
|
name: step.name,
|
|
result: {
|
|
success: result.success,
|
|
content: result.result,
|
|
formatted: result.formatted,
|
|
xmlFormatted: result.xmlFormatted,
|
|
error: result.error
|
|
},
|
|
stats: result.stats,
|
|
nextStep: nextStep ? nextStep.id : null,
|
|
sessionStatus: session.status,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur exécution step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur exécution étape',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère le status d'une session
|
|
*/
|
|
handleStepByStepStatus(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
const { sessionId } = req.params;
|
|
|
|
const session = sessionManager.getSession(sessionId);
|
|
|
|
res.json({
|
|
success: true,
|
|
session: {
|
|
id: session.id,
|
|
status: session.status,
|
|
createdAt: new Date(session.createdAt).toISOString(),
|
|
currentStep: session.currentStep,
|
|
completedSteps: session.completedSteps,
|
|
totalSteps: session.steps.length,
|
|
inputData: session.inputData,
|
|
steps: session.steps,
|
|
globalStats: session.globalStats,
|
|
results: session.results.map(r => ({
|
|
stepId: r.stepId,
|
|
system: r.system,
|
|
success: r.success,
|
|
timestamp: new Date(r.timestamp).toISOString(),
|
|
stats: r.stats
|
|
}))
|
|
},
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur status step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur récupération status',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reset une session
|
|
*/
|
|
handleStepByStepReset(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
const { sessionId } = req.body;
|
|
|
|
if (!sessionId) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'sessionId requis',
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
|
|
const session = sessionManager.resetSession(sessionId);
|
|
|
|
res.json({
|
|
success: true,
|
|
sessionId: session.id,
|
|
message: 'Session reset avec succès',
|
|
steps: session.steps,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur reset step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur reset session',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Export les résultats d'une session
|
|
*/
|
|
handleStepByStepExport(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
const { sessionId } = req.params;
|
|
|
|
const exportData = sessionManager.exportSession(sessionId);
|
|
|
|
res.setHeader('Content-Type', 'application/json');
|
|
res.setHeader('Content-Disposition', `attachment; filename="step-by-step-${sessionId}.json"`);
|
|
res.json(exportData);
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur export step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur export session',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Liste les sessions actives
|
|
*/
|
|
handleStepByStepSessions(req, res) {
|
|
try {
|
|
const { sessionManager } = require('../StepByStepSessionManager');
|
|
|
|
const sessions = sessionManager.listSessions();
|
|
|
|
res.json({
|
|
success: true,
|
|
sessions: sessions,
|
|
total: sessions.length,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur list sessions step-by-step: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur récupération sessions',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handler pour récupérer les personnalités disponibles
|
|
*/
|
|
async handleGetPersonalities(req, res) {
|
|
try {
|
|
const { getPersonalities } = require('../BrainConfig');
|
|
|
|
const personalities = await getPersonalities();
|
|
|
|
res.json({
|
|
success: true,
|
|
personalities: personalities || [],
|
|
total: (personalities || []).length,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh(`❌ Erreur récupération personnalités: ${error.message}`, 'ERROR');
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur récupération personnalités',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// INTERFACE WEB
|
|
// ========================================
|
|
|
|
/**
|
|
* Configure l'interface web
|
|
*/
|
|
setupWebInterface() {
|
|
// Page d'accueil - Dashboard MANUAL
|
|
this.app.get('/', (req, res) => {
|
|
res.send(this.generateManualDashboard());
|
|
});
|
|
|
|
// Route pour le log viewer
|
|
this.app.get('/logs-viewer.html', (req, res) => {
|
|
const fs = require('fs');
|
|
const logViewerPath = path.join(__dirname, '../../tools/logs-viewer.html');
|
|
|
|
try {
|
|
const content = fs.readFileSync(logViewerPath, 'utf-8');
|
|
res.setHeader('Content-Type', 'text/html; charset=utf-8');
|
|
res.send(content);
|
|
} catch (error) {
|
|
logSh(`❌ Erreur lecture log viewer: ${error.message}`, 'ERROR');
|
|
res.status(500).send(`Erreur: ${error.message}`);
|
|
}
|
|
});
|
|
|
|
// Route 404
|
|
this.app.use('*', (req, res) => {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: 'Route non trouvée',
|
|
path: req.originalUrl,
|
|
mode: 'MANUAL',
|
|
message: 'Cette route n\'existe pas en mode MANUAL'
|
|
});
|
|
});
|
|
|
|
logSh('🌐 Interface web configurée', 'DEBUG');
|
|
}
|
|
|
|
/**
|
|
* Génère le dashboard HTML du mode MANUAL
|
|
*/
|
|
generateManualDashboard() {
|
|
const uptime = Math.floor((Date.now() - this.stats.startTime) / 1000);
|
|
|
|
return `
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>SEO Generator - Mode MANUAL</title>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<style>
|
|
body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); min-height: 100vh; }
|
|
.container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 15px; box-shadow: 0 10px 30px rgba(0,0,0,0.1); }
|
|
.header { text-align: center; margin-bottom: 40px; }
|
|
.header h1 { color: #2d3748; margin-bottom: 10px; }
|
|
.mode-badge { background: #48bb78; color: white; padding: 8px 16px; border-radius: 20px; font-weight: bold; }
|
|
.stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 40px; }
|
|
.stat-card { background: #f7fafc; padding: 20px; border-radius: 10px; text-align: center; border: 1px solid #e2e8f0; }
|
|
.stat-number { font-size: 2em; font-weight: bold; color: #2d3748; }
|
|
.stat-label { color: #718096; margin-top: 5px; }
|
|
.section { margin: 30px 0; padding: 25px; border: 1px solid #e2e8f0; border-radius: 10px; background: #f9f9f9; }
|
|
.section h2 { color: #2d3748; margin-bottom: 15px; }
|
|
.button { display: inline-block; padding: 12px 24px; margin: 8px; background: linear-gradient(135deg, #667eea, #764ba2); color: white; text-decoration: none; border-radius: 8px; border: none; cursor: pointer; font-weight: 500; transition: all 0.2s; }
|
|
.button:hover { transform: translateY(-2px); box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4); }
|
|
.button.success { background: linear-gradient(135deg, #48bb78, #38a169); }
|
|
.button.warning { background: linear-gradient(135deg, #ed8936, #dd6b20); }
|
|
.alert { padding: 15px; margin: 20px 0; border-radius: 8px; border-left: 4px solid; }
|
|
.alert.success { background: #f0fff4; border-color: #48bb78; color: #22543d; }
|
|
.alert.info { background: #ebf8ff; border-color: #4299e1; color: #2a4365; }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="container">
|
|
<div class="header">
|
|
<h1>🎯 SEO Generator Server</h1>
|
|
<span class="mode-badge">MODE MANUAL</span>
|
|
<p style="color: #718096; margin-top: 15px;">Interface Client + API + Tests Modulaires</p>
|
|
</div>
|
|
|
|
<div class="alert success">
|
|
<strong>✅ Mode MANUAL Actif</strong><br>
|
|
Interface complète disponible • WebSocket temps réel • API complète
|
|
</div>
|
|
|
|
<div class="stats">
|
|
<div class="stat-card">
|
|
<div class="stat-number">${uptime}s</div>
|
|
<div class="stat-label">Uptime</div>
|
|
</div>
|
|
<div class="stat-card">
|
|
<div class="stat-number">${this.stats.requests}</div>
|
|
<div class="stat-label">Requêtes</div>
|
|
</div>
|
|
<div class="stat-card">
|
|
<div class="stat-number">${this.activeClients.size}</div>
|
|
<div class="stat-label">Clients WebSocket</div>
|
|
</div>
|
|
<div class="stat-card">
|
|
<div class="stat-number">${this.stats.testsExecuted}</div>
|
|
<div class="stat-label">Tests Exécutés</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🧪 Interface Test Modulaire</h2>
|
|
<p>Interface avancée pour tester toutes les combinaisons modulaires avec logs temps réel.</p>
|
|
<a href="/test-modulaire.html" target="_blank" class="button">🚀 Ouvrir Interface Test</a>
|
|
<a href="/step-by-step" target="_blank" class="button">⚡ Interface Step-by-Step</a>
|
|
<a href="/api/modulaire-config" target="_blank" class="button success">📋 Configuration API</a>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>📊 Monitoring & API</h2>
|
|
<p>Endpoints disponibles en mode MANUAL.</p>
|
|
<a href="/api/status" target="_blank" class="button">📊 Status API</a>
|
|
<a href="/api/stats" target="_blank" class="button">📈 Statistiques</a>
|
|
<button onclick="testConnection()" class="button success">🔍 Test Connexion</button>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🌐 WebSocket Logs</h2>
|
|
<p>Logs temps réel sur <strong>ws://localhost:${this.config.wsPort}</strong></p>
|
|
<button onclick="startLogViewer()" class="button warning">🔍 Ouvrir Log Viewer</button>
|
|
<div id="wsStatus" style="margin-top: 10px; padding: 10px; background: #e2e8f0; border-radius: 5px;">
|
|
Status: <span id="wsStatusText">Déconnecté</span>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>💡 Informations Mode MANUAL</h2>
|
|
<ul style="color: #4a5568; line-height: 1.6;">
|
|
<li><strong>Interface Client</strong> : Dashboard complet et interface de test</li>
|
|
<li><strong>API Complète</strong> : Tests individuels, benchmarks, configuration</li>
|
|
<li><strong>WebSocket</strong> : Logs temps réel sur port ${this.config.wsPort}</li>
|
|
<li><strong>Multi-Client</strong> : Plusieurs utilisateurs simultanés</li>
|
|
<li><strong>Pas de GSheets</strong> : Données test simulées ou fournies</li>
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
|
|
<script>
|
|
let ws = null;
|
|
|
|
function testConnection() {
|
|
fetch('/api/status')
|
|
.then(res => res.json())
|
|
.then(data => {
|
|
alert('✅ Connexion OK: ' + (data.mode || 'Mode MANUAL actif') + ' - Uptime: ' + Math.floor(data.uptime/1000) + 's');
|
|
})
|
|
.catch(err => {
|
|
alert('❌ Erreur connexion: ' + err.message);
|
|
});
|
|
}
|
|
|
|
function startLogViewer() {
|
|
fetch('/api/start-log-viewer', { method: 'POST' })
|
|
.then(res => res.json())
|
|
.then(data => {
|
|
if (data.success) {
|
|
alert('✅ Log Viewer lancé! WebSocket sur port ' + data.wsPort);
|
|
// Reconnecter le WebSocket pour voir les logs
|
|
connectWebSocket();
|
|
} else {
|
|
alert('❌ Erreur: ' + data.message);
|
|
}
|
|
})
|
|
.catch(err => {
|
|
alert('❌ Erreur lancement: ' + err.message);
|
|
});
|
|
}
|
|
|
|
function connectWebSocket() {
|
|
try {
|
|
ws = new WebSocket('ws://localhost:${this.config.wsPort}');
|
|
|
|
ws.onopen = () => {
|
|
document.getElementById('wsStatusText').textContent = 'Connecté ✅';
|
|
document.getElementById('wsStatus').style.background = '#c6f6d5';
|
|
};
|
|
|
|
ws.onclose = () => {
|
|
document.getElementById('wsStatusText').textContent = 'Déconnecté ❌';
|
|
document.getElementById('wsStatus').style.background = '#fed7d7';
|
|
setTimeout(connectWebSocket, 3000);
|
|
};
|
|
|
|
} catch (error) {
|
|
console.warn('WebSocket non disponible:', error.message);
|
|
}
|
|
}
|
|
|
|
// Auto-connect WebSocket
|
|
connectWebSocket();
|
|
|
|
// Refresh stats every 30s
|
|
setInterval(() => {
|
|
window.location.reload();
|
|
}, 30000);
|
|
</script>
|
|
</body>
|
|
</html>
|
|
`;
|
|
}
|
|
|
|
// ========================================
|
|
// WEBSOCKET SERVER
|
|
// ========================================
|
|
|
|
/**
|
|
* Configure le serveur WebSocket pour logs temps réel
|
|
*/
|
|
async setupWebSocketServer() {
|
|
try {
|
|
this.wsServer = new WebSocket.Server({
|
|
port: this.config.wsPort,
|
|
host: this.config.host
|
|
});
|
|
|
|
this.wsServer.on('connection', (ws, req) => {
|
|
this.handleWebSocketConnection(ws, req);
|
|
});
|
|
|
|
this.wsServer.on('error', (error) => {
|
|
logSh(`❌ Erreur WebSocket: ${error.message}`, 'ERROR');
|
|
});
|
|
|
|
logSh(`📡 WebSocket Server démarré sur ws://${this.config.host}:${this.config.wsPort}`, 'DEBUG');
|
|
|
|
} catch (error) {
|
|
logSh(`⚠️ Impossible de démarrer WebSocket: ${error.message}`, 'WARNING');
|
|
// Continue sans WebSocket si erreur
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gère les nouvelles connexions WebSocket
|
|
*/
|
|
handleWebSocketConnection(ws, req) {
|
|
const clientId = `client_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
|
const clientIP = req.socket.remoteAddress;
|
|
|
|
this.activeClients.add({ id: clientId, ws, ip: clientIP, connectedAt: Date.now() });
|
|
this.stats.sessions++;
|
|
|
|
logSh(`📡 Nouveau client WebSocket: ${clientId} (${clientIP})`, 'DEBUG');
|
|
|
|
// Message de bienvenue
|
|
ws.send(JSON.stringify({
|
|
type: 'welcome',
|
|
message: 'Connecté aux logs temps réel SEO Generator (Mode MANUAL)',
|
|
clientId: clientId,
|
|
timestamp: new Date().toISOString()
|
|
}));
|
|
|
|
// Gestion fermeture
|
|
ws.on('close', () => {
|
|
this.activeClients.delete(clientId);
|
|
logSh(`📡 Client WebSocket déconnecté: ${clientId}`, 'DEBUG');
|
|
});
|
|
|
|
// Gestion erreurs
|
|
ws.on('error', (error) => {
|
|
logSh(`⚠️ Erreur client WebSocket ${clientId}: ${error.message}`, 'WARNING');
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Diffuse un message à tous les clients WebSocket
|
|
*/
|
|
broadcastToClients(logData) {
|
|
if (this.activeClients.size === 0) return;
|
|
|
|
const message = JSON.stringify({
|
|
type: 'log',
|
|
...logData,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
this.activeClients.forEach(client => {
|
|
if (client.ws.readyState === WebSocket.OPEN) {
|
|
try {
|
|
client.ws.send(message);
|
|
} catch (error) {
|
|
// Client déconnecté, le supprimer
|
|
this.activeClients.delete(client.id);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Déconnecte tous les clients WebSocket
|
|
*/
|
|
disconnectAllClients() {
|
|
this.activeClients.forEach(client => {
|
|
try {
|
|
client.ws.close();
|
|
} catch (error) {
|
|
// Ignore les erreurs de fermeture
|
|
}
|
|
});
|
|
|
|
this.activeClients.clear();
|
|
logSh('📡 Tous les clients WebSocket déconnectés', 'DEBUG');
|
|
}
|
|
|
|
// ========================================
|
|
// SERVEUR HTTP
|
|
// ========================================
|
|
|
|
/**
|
|
* Démarre le serveur HTTP
|
|
*/
|
|
async startHTTPServer() {
|
|
return new Promise((resolve, reject) => {
|
|
try {
|
|
this.server = this.app.listen(this.config.port, this.config.host, () => {
|
|
resolve();
|
|
});
|
|
|
|
this.server.on('error', (error) => {
|
|
reject(error);
|
|
});
|
|
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
// ========================================
|
|
// MONITORING
|
|
// ========================================
|
|
|
|
/**
|
|
* Démarre le monitoring du serveur
|
|
*/
|
|
startMonitoring() {
|
|
const MONITOR_INTERVAL = 30000; // 30 secondes
|
|
|
|
this.monitorInterval = setInterval(() => {
|
|
this.performMonitoring();
|
|
}, MONITOR_INTERVAL);
|
|
|
|
logSh('💓 Monitoring ManualServer démarré', 'DEBUG');
|
|
}
|
|
|
|
/**
|
|
* Effectue le monitoring périodique
|
|
*/
|
|
performMonitoring() {
|
|
const memUsage = process.memoryUsage();
|
|
const uptime = Date.now() - this.stats.startTime;
|
|
|
|
logSh(`💓 ManualServer Health - Clients: ${this.activeClients.size} | Requêtes: ${this.stats.requests} | RAM: ${Math.round(memUsage.rss / 1024 / 1024)}MB`, 'TRACE');
|
|
|
|
// Nettoyage clients WebSocket morts
|
|
this.cleanupDeadClients();
|
|
}
|
|
|
|
/**
|
|
* Nettoie les clients WebSocket déconnectés
|
|
*/
|
|
cleanupDeadClients() {
|
|
let cleaned = 0;
|
|
|
|
this.activeClients.forEach(client => {
|
|
if (client.ws.readyState !== WebSocket.OPEN) {
|
|
this.activeClients.delete(client.id);
|
|
cleaned++;
|
|
}
|
|
});
|
|
|
|
if (cleaned > 0) {
|
|
logSh(`🧹 ${cleaned} clients WebSocket morts nettoyés`, 'DEBUG');
|
|
}
|
|
}
|
|
|
|
// ========================================
|
|
// ÉTAT ET CONTRÔLES
|
|
// ========================================
|
|
|
|
/**
|
|
* Vérifie s'il y a des clients actifs
|
|
*/
|
|
hasActiveClients() {
|
|
return this.activeClients.size > 0;
|
|
}
|
|
|
|
/**
|
|
* Retourne l'état du serveur MANUAL
|
|
*/
|
|
getStatus() {
|
|
return {
|
|
isRunning: this.isRunning,
|
|
config: { ...this.config },
|
|
stats: {
|
|
...this.stats,
|
|
uptime: Date.now() - this.stats.startTime
|
|
},
|
|
activeClients: this.activeClients.size,
|
|
urls: {
|
|
dashboard: `http://localhost:${this.config.port}`,
|
|
testInterface: `http://localhost:${this.config.port}/test-modulaire.html`,
|
|
apiStatus: `http://localhost:${this.config.port}/api/status`,
|
|
websocket: `ws://localhost:${this.config.wsPort}`
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
// ============= EXPORTS =============
|
|
module.exports = { ManualServer }; |