Update pdf-server.js

pdf-server.js

@@ -1,14 +1,24 @@
 const express = require('express');
 const { chromium } = require('playwright-core');
+const fs = require('fs');
+const path = require('path');
 
 const app = express();
 app.use(express.json({ limit: '50mb' }));
 
-// ==================== CONFIGURATION ====================
 const PORT = 3000;
 const CHROMIUM_PATH = '/usr/bin/chromium-browser';
 
-// Formats KDP
+// ==================== DEVICES PRESETS ====================
+const DEVICES = {
+  'desktop': { width: 1920, height: 1080, userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' },
+  'laptop': { width: 1366, height: 768, userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36' },
+  'tablet': { width: 768, height: 1024, userAgent: 'Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X) AppleWebKit/605.1.15' },
+  'mobile': { width: 375, height: 812, userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15' },
+  'mobile-android': { width: 360, height: 740, userAgent: 'Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36' },
+};
+
+// Formats PDF
 const FORMATS = {
   '6x9': { width: '6in', height: '9in' },
   '5x8': { width: '5in', height: '8in' },
@@ -20,128 +30,118 @@ const FORMATS = {
 
 // ==================== HEALTH CHECK ====================
 app.get('/health', (req, res) => {
-  res.json({ status: 'ok', service: 'pdf-server' });
+  res.json({ status: 'ok', service: 'pdf-server', features: ['pdf', 'screenshot', 'video', 'scrape'] });
 });
 
 // ==================== GÉNÉRATION PDF ====================
 app.post('/generate-pdf', async (req, res) => {
-  const startTime = Date.now();
   let browser = null;
-
   try {
     const {
       html,
+      url,
       format = '6x9',
       margins = { top: '0.75in', bottom: '0.75in', left: '0.5in', right: '0.5in' },
       printBackground = true,
-      waitForImages = true,
-      waitTimeout = 30000,
     } = req.body;
 
-    if (!html) {
-      return res.status(400).json({ error: 'html requis' });
+    if (!html && !url) {
+      return res.status(400).json({ error: 'html ou url requis' });
     }
 
-    console.log(`📄 Génération PDF (format: ${format})...`);
+    console.log(`📄 Génération PDF...`);
 
-    // Lancer le navigateur
     browser = await chromium.launch({
       executablePath: CHROMIUM_PATH,
       headless: true,
-      args: [
-        '--no-sandbox',
-        '--disable-setuid-sandbox',
-        '--disable-dev-shm-usage',
-        '--disable-gpu',
-        '--single-process',
-      ],
+      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
     });
 
-    const context = await browser.newContext();
-    const page = await context.newPage();
-
-    // Charger le HTML
-    await page.setContent(html, {
-      waitUntil: 'networkidle',
-      timeout: waitTimeout,
-    });
+    const page = await browser.newPage();
 
-    // Attendre que les images soient chargées
-    if (waitForImages) {
-      await page.evaluate(() => {
-        return Promise.all(
-          Array.from(document.images)
-            .filter(img => !img.complete)
-            .map(img => new Promise(resolve => {
-              img.onload = img.onerror = resolve;
-              setTimeout(resolve, 5000);
-            }))
-        );
-      });
+    if (url) {
+      await page.goto(url, { waitUntil: 'networkidle', timeout: 60000 });
+    } else {
+      await page.setContent(html, { waitUntil: 'networkidle', timeout: 60000 });
     }
 
-    // Attendre un peu pour le rendu CSS
-    await page.waitForTimeout(500);
+    // Attendre images
+    await page.evaluate(() => {
+      return Promise.all(
+        Array.from(document.images)
+          .filter(img => !img.complete)
+          .map(img => new Promise(resolve => {
+            img.onload = img.onerror = resolve;
+            setTimeout(resolve, 5000);
+          }))
+      );
+    });
+
+    await page.waitForTimeout(1000);
 
-    // Configuration du format
     const formatConfig = FORMATS[format] || FORMATS['6x9'];
 
-    // Générer le PDF
     const pdfBuffer = await page.pdf({
       width: formatConfig.width,
       height: formatConfig.height,
       margin: margins,
-      printBackground: printBackground,
+      printBackground,
       preferCSSPageSize: true,
     });
 
     await browser.close();
-    browser = null;
-
-    const duration = Date.now() - startTime;
-    console.log(`✅ PDF généré (${(pdfBuffer.length / 1024 / 1024).toFixed(2)} MB, ${duration}ms)`);
 
-    // Retourner en base64
     res.json({
       success: true,
       pdf: pdfBuffer.toString('base64'),
-      size_bytes: pdfBuffer.length,
       size_mb: (pdfBuffer.length / 1024 / 1024).toFixed(2),
-      duration_ms: duration,
     });
 
   } catch (error) {
-    console.error('❌ Erreur:', error.message);
+    console.error('❌ PDF Error:', error.message);
     if (browser) await browser.close();
-    res.status(500).json({ error: error.message });
+    res.status(500).json({ error: error.message, stack: error.stack });
   }
 });
 
 // ==================== SCREENSHOT ====================
 app.post('/screenshot', async (req, res) => {
   let browser = null;
-
   try {
     const {
       url,
       html,
+      device = 'desktop',
       fullPage = true,
-      width = 1920,
-      height = 1080,
+      width,
+      height,
+      selector,
+      waitFor,
+      delay = 0,
     } = req.body;
 
     if (!url && !html) {
       return res.status(400).json({ error: 'url ou html requis' });
     }
 
+    const deviceConfig = DEVICES[device] || DEVICES['desktop'];
+    const viewportWidth = width || deviceConfig.width;
+    const viewportHeight = height || deviceConfig.height;
+
     browser = await chromium.launch({
       executablePath: CHROMIUM_PATH,
       headless: true,
       args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
     });
 
-    const page = await browser.newPage();
-    await page.setViewportSize({ width, height });
+    const context = await browser.newContext({
+      viewport: { width: viewportWidth, height: viewportHeight },
+      userAgent: deviceConfig.userAgent,
+      isMobile: device.includes('mobile') || device === 'tablet',
+      hasTouch: device.includes('mobile') || device === 'tablet',
+    });
+
+    const page = await context.newPage();
 
     if (url) {
       await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
@@ -149,16 +149,160 @@ app.post('/screenshot', async (req, res) => {
       await page.setContent(html, { waitUntil: 'networkidle' });
     }
 
-    const screenshot = await page.screenshot({ fullPage, type: 'png' });
+    if (waitFor) {
+      await page.waitForSelector(waitFor, { timeout: 10000 });
+    }
+
+    if (delay > 0) {
+      await page.waitForTimeout(delay);
+    }
+
+    let screenshotOptions = { type: 'png', fullPage };
+
+    if (selector) {
+      const element = await page.$(selector);
+      if (element) {
+        screenshotOptions = { type: 'png' };
+        const screenshot = await element.screenshot(screenshotOptions);
+        await browser.close();
+        return res.json({
+          success: true,
+          screenshot: screenshot.toString('base64'),
+          device,
+          viewport: { width: viewportWidth, height: viewportHeight },
+        });
+      }
+    }
+
+    const screenshot = await page.screenshot(screenshotOptions);
     await browser.close();
 
     res.json({
       success: true,
       screenshot: screenshot.toString('base64'),
-      size_bytes: screenshot.length,
+      device,
+      viewport: { width: viewportWidth, height: viewportHeight },
+    });
+
+  } catch (error) {
+    console.error('❌ Screenshot Error:', error.message);
+    if (browser) await browser.close();
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ==================== VIDEO RECORDING ====================
+app.post('/record-video', async (req, res) => {
+  let browser = null;
+  const videoDir = '/tmp/videos';
+  
+  try {
+    const {
+      url,
+      device = 'desktop',
+      duration = 5000,
+      scrollSpeed = 100,
+      scrollToBottom = true,
+      actions = [],
+    } = req.body;
+
+    if (!url) {
+      return res.status(400).json({ error: 'url requis' });
+    }
+
+    // Créer le dossier vidéo
+    if (!fs.existsSync(videoDir)) {
+      fs.mkdirSync(videoDir, { recursive: true });
+    }
+
+    const deviceConfig = DEVICES[device] || DEVICES['desktop'];
+
+    browser = await chromium.launch({
+      executablePath: CHROMIUM_PATH,
+      headless: true,
+      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
+    });
+
+    const context = await browser.newContext({
+      viewport: { width: deviceConfig.width, height: deviceConfig.height },
+      userAgent: deviceConfig.userAgent,
+      isMobile: device.includes('mobile') || device === 'tablet',
+      recordVideo: {
+        dir: videoDir,
+        size: { width: deviceConfig.width, height: deviceConfig.height },
+      },
+    });
+
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
+
+    // Exécuter les actions personnalisées
+    for (const action of actions) {
+      switch (action.type) {
+        case 'wait':
+          await page.waitForTimeout(action.duration || 1000);
+          break;
+        case 'click':
+          await page.click(action.selector);
+          break;
+        case 'type':
+          await page.fill(action.selector, action.text);
+          break;
+        case 'scroll':
+          await page.evaluate((y) => window.scrollBy(0, y), action.y || 500);
+          break;
+        case 'screenshot':
+          // Pause visuelle
+          await page.waitForTimeout(500);
+          break;
+      }
+    }
+
+    // Scroll automatique vers le bas
+    if (scrollToBottom) {
+      const scrollHeight = await page.evaluate(() => document.body.scrollHeight);
+      const viewportHeight = deviceConfig.height;
+      let currentScroll = 0;
+
+      while (currentScroll < scrollHeight) {
+        await page.evaluate((y) => window.scrollTo(0, y), currentScroll);
+        await page.waitForTimeout(scrollSpeed);
+        currentScroll += viewportHeight / 2;
+      }
+
+      // Retour en haut
+      await page.evaluate(() => window.scrollTo(0, 0));
+    } else {
+      await page.waitForTimeout(duration);
+    }
+
+    await page.waitForTimeout(1000);
+    await context.close();
+    await browser.close();
+
+    // Récupérer le fichier vidéo
+    const files = fs.readdirSync(videoDir);
+    const videoFile = files.find(f => f.endsWith('.webm'));
+
+    if (!videoFile) {
+      return res.status(500).json({ error: 'Video file not created' });
+    }
+
+    const videoPath = path.join(videoDir, videoFile);
+    const videoBuffer = fs.readFileSync(videoPath);
+
+    // Nettoyer
+    fs.unlinkSync(videoPath);
+
+    res.json({
+      success: true,
+      video: videoBuffer.toString('base64'),
+      format: 'webm',
+      size_mb: (videoBuffer.length / 1024 / 1024).toFixed(2),
     });
 
   } catch (error) {
+    console.error('❌ Video Error:', error.message);
     if (browser) await browser.close();
     res.status(500).json({ error: error.message });
   }
@@ -167,59 +311,123 @@ app.post('/screenshot', async (req, res) => {
 // ==================== SCRAPING ====================
 app.post('/scrape', async (req, res) => {
   let browser = null;
-
   try {
     const {
       url,
-      selector,
+      device = 'desktop',
+      selectors = {},
       waitFor,
-      evaluate,
+      javascript,
     } = req.body;
 
     if (!url) {
       return res.status(400).json({ error: 'url requis' });
     }
 
+    const deviceConfig = DEVICES[device] || DEVICES['desktop'];
+
     browser = await chromium.launch({
       executablePath: CHROMIUM_PATH,
       headless: true,
       args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
     });
 
-    const page = await browser.newPage();
+    const context = await browser.newContext({
+      viewport: { width: deviceConfig.width, height: deviceConfig.height },
+      userAgent: deviceConfig.userAgent,
+    });
+
+    const page = await context.newPage();
     await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
 
     if (waitFor) {
       await page.waitForSelector(waitFor, { timeout: 10000 });
     }
 
-    let result = {};
+    const result = {
+      url: page.url(),
+      title: await page.title(),
+    };
+
+    // Extraire avec les sélecteurs fournis
+    for (const [key, selector] of Object.entries(selectors)) {
+      try {
+        result[key] = await page.$$eval(selector, els => els.map(el => ({
+          text: el.textContent?.trim(),
+          html: el.innerHTML,
+          href: el.href || null,
+          src: el.src || null,
+        })));
+      } catch (e) {
+        result[key] = [];
+      }
+    }
 
-    // Récupérer le HTML
-    result.html = await page.content();
-    result.title = await page.title();
-    result.url = page.url();
+    // Exécuter du JavaScript personnalisé
+    if (javascript) {
+      result.custom = await page.evaluate(javascript);
+    }
 
-    // Si un sélecteur est spécifié
-    if (selector) {
-      result.elements = await page.$$eval(selector, els => els.map(el => ({
-        text: el.textContent?.trim(),
-        html: el.innerHTML,
-        href: el.href || null,
-        src: el.src || null,
-      })));
+    await browser.close();
+    res.json({ success: true, ...result });
+
+  } catch (error) {
+    console.error('❌ Scrape Error:', error.message);
+    if (browser) await browser.close();
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ==================== MULTI-SCREENSHOT ====================
+app.post('/multi-screenshot', async (req, res) => {
+  let browser = null;
+  try {
+    const {
+      url,
+      devices = ['desktop', 'tablet', 'mobile'],
+      fullPage = true,
+    } = req.body;
+
+    if (!url) {
+      return res.status(400).json({ error: 'url requis' });
     }
 
-    // Si un script personnalisé est fourni
-    if (evaluate) {
-      result.custom = await page.evaluate(evaluate);
+    browser = await chromium.launch({
+      executablePath: CHROMIUM_PATH,
+      headless: true,
+      args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
+    });
+
+    const screenshots = {};
+
+    for (const device of devices) {
+      const deviceConfig = DEVICES[device] || DEVICES['desktop'];
+
+      const context = await browser.newContext({
+        viewport: { width: deviceConfig.width, height: deviceConfig.height },
+        userAgent: deviceConfig.userAgent,
+        isMobile: device.includes('mobile') || device === 'tablet',
+      });
+
+      const page = await context.newPage();
+      await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
+
+      const screenshot = await page.screenshot({ type: 'png', fullPage });
+      screenshots[device] = screenshot.toString('base64');
+
+      await context.close();
     }
 
     await browser.close();
 
-    res.json({ success: true, ...result });
+    res.json({
+      success: true,
+      screenshots,
+      devices,
+    });
 
   } catch (error) {
+    console.error('❌ Multi-Screenshot Error:', error.message);
     if (browser) await browser.close();
     res.status(500).json({ error: error.message });
   }
@@ -228,4 +436,6 @@ app.post('/scrape', async (req, res) => {
 // ==================== DÉMARRAGE ====================
 app.listen(PORT, '0.0.0.0', () => {
   console.log(`🚀 PDF Server running on port ${PORT}`);
+  console.log(`📱 Devices: ${Object.keys(DEVICES).join(', ')}`);
+  console.log(`📄 PDF Formats: ${Object.keys(FORMATS).join(', ')}`);
 });