583 lines
21 KiB
JavaScript
583 lines
21 KiB
JavaScript
const express = require('express');
|
|
const cors = require('cors');
|
|
const path = require('path');
|
|
require('dotenv').config();
|
|
|
|
const { logSh } = require('./lib/ErrorReporting'); // Using unified logSh from ErrorReporting
|
|
|
|
// Import du workflow principal (version simplifiée pour démarrage)
|
|
const { handleFullWorkflow, testMainWorkflow } = require('./lib/SimpleMain');
|
|
const { getBrainConfig } = require('./lib/BrainConfig');
|
|
const { testLLMManagerComplete } = require('./lib/LLMManager');
|
|
const { triggerAutonomousWorkflow, testDigitalOceanConnection, readCSVDataWithXMLFileName, fetchXMLFromDigitalOceanSimple } = require('./lib/DigitalOceanWorkflow');
|
|
|
|
// Import du workflow modulaire
|
|
const { handleModularWorkflow, benchmarkStacks } = require('./lib/main_modulaire');
|
|
|
|
const app = express();
|
|
const PORT = process.env.PORT || 3000;
|
|
|
|
// Middleware
|
|
app.use(express.json());
|
|
app.use(cors());
|
|
app.use(express.static('public')); // Pour servir les fichiers statiques
|
|
|
|
// Dashboard HTML
|
|
app.get('/', (req, res) => {
|
|
res.send(`
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>SEO Generator Server - Dashboard</title>
|
|
<style>
|
|
body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
|
|
.container { max-width: 1200px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
|
|
h1 { color: #333; text-align: center; margin-bottom: 30px; }
|
|
.section { margin: 20px 0; padding: 20px; border: 1px solid #ddd; border-radius: 5px; }
|
|
.button { display: inline-block; padding: 12px 24px; margin: 10px 5px; background: #007cba; color: white; text-decoration: none; border-radius: 5px; border: none; cursor: pointer; font-size: 14px; }
|
|
.button:hover { background: #005a87; }
|
|
.button.secondary { background: #28a745; }
|
|
.button.warning { background: #ffc107; color: #333; }
|
|
.status { padding: 10px; margin: 10px 0; border-radius: 5px; }
|
|
.success { background: #d4edda; color: #155724; border: 1px solid #c3e6cb; }
|
|
.info { background: #d1ecf1; color: #0c5460; border: 1px solid #bee5eb; }
|
|
.result { background: #f8f9fa; padding: 15px; margin: 10px 0; border-radius: 5px; border: 1px solid #dee2e6; max-height: 400px; overflow-y: auto; }
|
|
pre { margin: 0; white-space: pre-wrap; word-wrap: break-word; }
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="container">
|
|
<h1>🚀 SEO Generator Server Dashboard</h1>
|
|
|
|
<div class="status success">
|
|
<strong>Status:</strong> Serveur actif depuis ${Math.floor(process.uptime())} secondes
|
|
<br><strong>Version Node:</strong> ${process.version}
|
|
<br><strong>Timestamp:</strong> ${new Date().toISOString()}
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🎯 Workflow Principal</h2>
|
|
<p>Traitement automatique des Google Sheets avec génération de contenu SEO.</p>
|
|
<button class="button" onclick="checkAndProcess()">🔍 Vérifier Google Sheets & Traiter</button>
|
|
<button class="button secondary" onclick="testWorkflow()">🧪 Test Workflow Complet</button>
|
|
<div id="workflow-result" class="result" style="display:none;"></div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🤖 Tests LLM</h2>
|
|
<p>Vérifier la connectivité et fonctionnement des modèles IA.</p>
|
|
<button class="button warning" onclick="testLLMs()">🌐 Test Connectivité LLM</button>
|
|
<div id="llm-result" class="result" style="display:none;"></div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>📊 Configuration</h2>
|
|
<p>Gestion des données et personnalités IA.</p>
|
|
<button class="button" onclick="testConfig()">⚙️ Test Configuration</button>
|
|
<div id="config-result" class="result" style="display:none;"></div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🌊 DigitalOcean Workflow</h2>
|
|
<p>Récupération XML depuis DigitalOcean et traitement automatique.</p>
|
|
<button class="button" onclick="testDOConnection()">🧪 Test DigitalOcean</button>
|
|
<button class="button secondary" onclick="processDOWorkflow()">🚀 Traiter Workflow DO</button>
|
|
<div id="do-result" class="result" style="display:none;"></div>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🧪 Interface Test Modulaire</h2>
|
|
<p>Interface web avancée pour tester toutes les combinaisons modulaires.</p>
|
|
<a href="/test-modulaire.html" target="_blank" class="button">🚀 Ouvrir Interface Test</a>
|
|
</div>
|
|
|
|
<div class="section">
|
|
<h2>🔗 Tests Réseau</h2>
|
|
<button class="button" onclick="pingServices()">📡 Ping Services</button>
|
|
<div id="ping-result" class="result" style="display:none;"></div>
|
|
</div>
|
|
</div>
|
|
|
|
<script>
|
|
async function apiCall(url, resultDiv) {
|
|
const element = document.getElementById(resultDiv);
|
|
element.style.display = 'block';
|
|
element.innerHTML = '<pre>⏳ Chargement...</pre>';
|
|
|
|
try {
|
|
const response = await fetch(url);
|
|
const data = await response.json();
|
|
element.innerHTML = '<pre>' + JSON.stringify(data, null, 2) + '</pre>';
|
|
} catch (error) {
|
|
element.innerHTML = '<pre style="color: red;">❌ Erreur: ' + error.message + '</pre>';
|
|
}
|
|
}
|
|
|
|
function checkAndProcess() {
|
|
apiCall('/api/check-and-process', 'workflow-result');
|
|
}
|
|
|
|
function testWorkflow() {
|
|
apiCall('/api/test-workflow', 'workflow-result');
|
|
}
|
|
|
|
function testLLMs() {
|
|
apiCall('/api/test-llm', 'llm-result');
|
|
}
|
|
|
|
function testConfig() {
|
|
apiCall('/api/test-config', 'config-result');
|
|
}
|
|
|
|
function testDOConnection() {
|
|
apiCall('/api/test-digitalocean', 'do-result');
|
|
}
|
|
|
|
function processDOWorkflow() {
|
|
const rowNumber = prompt('Numéro de ligne à traiter:', '2');
|
|
if (rowNumber) {
|
|
apiCall('/api/digitalocean-workflow/' + rowNumber, 'do-result');
|
|
}
|
|
}
|
|
|
|
function pingServices() {
|
|
apiCall('/ping-all', 'ping-result');
|
|
}
|
|
</script>
|
|
</body>
|
|
</html>
|
|
`);
|
|
});
|
|
|
|
// API Routes
|
|
app.get('/api/status', (req, res) => {
|
|
res.json({
|
|
success: true,
|
|
status: 'running',
|
|
uptime: process.uptime(),
|
|
timestamp: new Date().toISOString(),
|
|
node_version: process.version,
|
|
memory: process.memoryUsage()
|
|
});
|
|
});
|
|
|
|
// Test du workflow principal
|
|
app.get('/api/test-workflow', async (req, res) => {
|
|
try {
|
|
logSh('🧪 Test workflow principal...', 'INFO'); // Using logSh instead of console.log
|
|
const result = await testMainWorkflow();
|
|
res.json({
|
|
success: true,
|
|
message: 'Test workflow terminé avec succès',
|
|
result: result
|
|
});
|
|
} catch (error) {
|
|
logSh('❌ Erreur test workflow: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
stack: error.stack
|
|
});
|
|
}
|
|
});
|
|
|
|
// Test des LLM
|
|
app.get('/api/test-llm', async (req, res) => {
|
|
try {
|
|
logSh('🌐 Test connectivité LLM...', 'INFO'); // Using logSh instead of console.log
|
|
const result = await testLLMManagerComplete();
|
|
res.json({
|
|
success: true,
|
|
message: 'Test LLM terminé',
|
|
result: result
|
|
});
|
|
} catch (error) {
|
|
logSh('❌ Erreur test LLM: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Test de configuration
|
|
app.get('/api/test-config', async (req, res) => {
|
|
try {
|
|
logSh('⚙️ Test configuration...', 'INFO'); // Using logSh instead of console.log
|
|
const result = await getBrainConfig(2);
|
|
res.json({
|
|
success: true,
|
|
message: 'Test configuration terminé',
|
|
result: result
|
|
});
|
|
} catch (error) {
|
|
logSh('❌ Erreur test config: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Test connexion DigitalOcean
|
|
app.get('/api/test-digitalocean', async (req, res) => {
|
|
try {
|
|
logSh('🧪 Test connexion DigitalOcean...', 'INFO'); // Using logSh instead of console.log
|
|
const result = await testDigitalOceanConnection();
|
|
|
|
res.json({
|
|
success: result,
|
|
message: result ? 'Connexion DigitalOcean fonctionnelle' : 'Connexion DigitalOcean échouée',
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh('❌ Erreur test DO: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
// Déclencher workflow DigitalOcean pour une ligne spécifique
|
|
app.get('/api/digitalocean-workflow/:rowNumber', async (req, res) => {
|
|
try {
|
|
const rowNumber = parseInt(req.params.rowNumber);
|
|
|
|
if (!rowNumber || rowNumber < 2) {
|
|
return res.status(400).json({
|
|
success: false,
|
|
error: 'Numéro de ligne invalide (minimum 2)'
|
|
});
|
|
}
|
|
|
|
logSh(`🌊 Déclenchement workflow DigitalOcean ligne ${rowNumber}...`, 'INFO'); // Using logSh instead of console.log
|
|
|
|
const result = await triggerAutonomousWorkflow(rowNumber);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: `✅ Workflow DigitalOcean ligne ${rowNumber} terminé`,
|
|
rowNumber: rowNumber,
|
|
result: result,
|
|
source: 'digitalocean_autonomous'
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh('❌ Erreur workflow DO: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
rowNumber: req.params.rowNumber,
|
|
stack: error.stack
|
|
});
|
|
}
|
|
});
|
|
|
|
// Récupérer données CSV pour une ligne (debug)
|
|
app.get('/api/digitalocean-csv/:rowNumber', async (req, res) => {
|
|
try {
|
|
const rowNumber = parseInt(req.params.rowNumber);
|
|
|
|
logSh(`📋 Récupération CSV ligne ${rowNumber}...`, 'INFO'); // Using logSh instead of console.log
|
|
|
|
const csvData = await readCSVDataWithXMLFileName(rowNumber);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'Données CSV récupérées',
|
|
rowNumber: rowNumber,
|
|
csvData: csvData
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh('❌ Erreur CSV DO: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
rowNumber: req.params.rowNumber
|
|
});
|
|
}
|
|
});
|
|
|
|
// Récupérer XML depuis DigitalOcean (debug)
|
|
app.get('/api/digitalocean-xml/:fileName', async (req, res) => {
|
|
try {
|
|
const fileName = req.params.fileName;
|
|
|
|
logSh(`📄 Récupération XML: ${fileName}`, 'INFO'); // Using logSh instead of console.log
|
|
|
|
const xmlContent = await fetchXMLFromDigitalOceanSimple(fileName);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: 'XML récupéré depuis DigitalOcean',
|
|
fileName: fileName,
|
|
contentLength: xmlContent.length,
|
|
content: xmlContent.substring(0, 500) + '...' // Premier extrait
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh('❌ Erreur XML DO: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
fileName: req.params.fileName
|
|
});
|
|
}
|
|
});
|
|
|
|
// Vérifier Google Sheets et traiter
|
|
app.get('/api/check-and-process', async (req, res) => {
|
|
try {
|
|
logSh('🔍 Vérification Google Sheets...', 'INFO'); // Using logSh instead of console.log
|
|
|
|
// TODO: Implémenter vérification Google Sheets
|
|
// Pour l'instant, on simule avec des données test
|
|
const testData = {
|
|
csvData: {
|
|
mc0: 'plaque signalétique professionnelle',
|
|
t0: 'Découvrez nos plaques signalétiques sur mesure',
|
|
personality: { nom: 'Marc', style: 'professionnel' },
|
|
tMinus1: 'Signalétique entreprise',
|
|
mcPlus1: 'plaque dibond,plaque aluminium,plaque gravée,signalétique bureau',
|
|
tPlus1: 'Plaque Dibond,Plaque Aluminium,Plaque Gravée,Signalétique Bureau'
|
|
},
|
|
xmlTemplate: Buffer.from('<?xml version="1.0"?><article><h1>|Title_Main{{T0}}|</h1><p>|Content_Intro{{MC0}}|</p></article>').toString('base64'),
|
|
source: 'node_server_check'
|
|
};
|
|
|
|
const result = await handleFullWorkflow(testData);
|
|
|
|
res.json({
|
|
success: true,
|
|
message: '✅ Traitement Google Sheets terminé',
|
|
processed: true,
|
|
result: result
|
|
});
|
|
|
|
} catch (error) {
|
|
logSh('❌ Erreur check-and-process: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: error.message,
|
|
stack: error.stack
|
|
});
|
|
}
|
|
});
|
|
|
|
// 🆕 ROUTE PING MULTIPLE (Tests réseau)
|
|
app.get('/ping-all', async (req, res) => {
|
|
const targets = [
|
|
'https://www.google.com',
|
|
'https://api.openai.com',
|
|
'https://api.anthropic.com',
|
|
'https://generativelanguage.googleapis.com'
|
|
];
|
|
|
|
logSh('🔍 Ping services réseau...', 'INFO'); // Using logSh instead of console.log
|
|
|
|
const results = await Promise.allSettled(
|
|
targets.map(async (url) => {
|
|
const startTime = Date.now();
|
|
try {
|
|
const response = await fetch(url, { method: 'HEAD', timeout: 5000 });
|
|
return {
|
|
url,
|
|
success: true,
|
|
status: response.status,
|
|
duration_ms: Date.now() - startTime,
|
|
message: `✅ ${url} accessible`
|
|
};
|
|
} catch (error) {
|
|
return {
|
|
url,
|
|
success: false,
|
|
error: error.message,
|
|
duration_ms: Date.now() - startTime,
|
|
message: `❌ ${url} inaccessible`
|
|
};
|
|
}
|
|
})
|
|
);
|
|
|
|
const successCount = results.filter(r => r.value?.success || r.status === 'fulfilled').length;
|
|
|
|
res.json({
|
|
timestamp: new Date().toISOString(),
|
|
summary: `${successCount}/${targets.length} services accessibles`,
|
|
results: results.map(r => r.value || r.reason)
|
|
});
|
|
});
|
|
|
|
// ============= NOUVEAUX ENDPOINTS MODULAIRES =============
|
|
|
|
// Test modulaire individuel
|
|
app.post('/api/test-modulaire', async (req, res) => {
|
|
try {
|
|
const config = req.body;
|
|
|
|
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)'
|
|
});
|
|
}
|
|
|
|
const result = await handleModularWorkflow(config);
|
|
|
|
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()
|
|
});
|
|
}
|
|
});
|
|
|
|
// Benchmark modulaire complet
|
|
app.post('/api/benchmark-modulaire', async (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;
|
|
|
|
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()
|
|
});
|
|
}
|
|
});
|
|
|
|
// Endpoint pour récupérer la configuration disponible
|
|
app.get('/api/modulaire-config', (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
|
|
});
|
|
}
|
|
});
|
|
|
|
// Middleware de gestion d'erreurs global
|
|
app.use((error, req, res, next) => {
|
|
logSh('❌ Erreur serveur: ' + error.message, 'ERROR'); // Using logSh instead of console.error
|
|
res.status(500).json({
|
|
success: false,
|
|
error: 'Erreur serveur interne',
|
|
message: error.message,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
});
|
|
|
|
// Route 404
|
|
app.use('*', (req, res) => {
|
|
res.status(404).json({
|
|
success: false,
|
|
error: 'Route non trouvée',
|
|
path: req.originalUrl,
|
|
message: 'Cette route n\'existe pas'
|
|
});
|
|
});
|
|
|
|
// Démarrage serveur
|
|
app.listen(PORT, () => {
|
|
logSh(`🚀 === SEO Generator Server Dashboard ===`, 'INFO'); // Using logSh instead of console.log
|
|
logSh(`🌐 Interface Web: http://localhost:${PORT}`, 'INFO'); // Using logSh instead of console.log
|
|
logSh(`📊 API Status: http://localhost:${PORT}/api/status`, 'INFO'); // Using logSh instead of console.log
|
|
logSh(`🔗 Tests Réseau: http://localhost:${PORT}/ping-all`, 'INFO'); // Using logSh instead of console.log
|
|
logSh(`✅ Serveur prêt à traiter les workflows SEO !`, 'INFO'); // Using logSh instead of console.log
|
|
logSh(`🎯 Version: Phase 2 Anti-Détection Ready`, 'INFO'); // Using logSh instead of console.log
|
|
}); |