@imenam/simple-scraper 1.0.29 → 1.0.30

package/README.md

@@ -355,7 +355,7 @@ Capture a screenshot of a page. Use `session_id` to capture an active session in
 
 The capture area is resolved by precedence: `selector` → `clip` → `full_page` → the visible viewport.
 
-Captures run one at a time across the whole server (this tool and the GUI views alike), each after bringing its page to the front: with several pages open, headless Chrome stalls the capture of a page that is not in front. A capture that gets no answer within 20 s fails without holding up the next ones.
+Captures run one at a time across the whole server (this tool and the GUI views alike), each after bringing its page to the front: with several pages open, headless Chrome stalls the capture of a page that is not in front. A capture of this tool that gets no answer within 20 s fails without holding up the next ones. The GUI views capture through a CDP session of their own, outside Puppeteer's screenshot lock, with a 4 s limit: a stalled capture is dropped along with its session and never blocks the following ones.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
@@ -412,7 +412,7 @@ Every browser of the scraper starts with Chromium's sandbox disabled (`--no-sand
 
 ### Keep-alive
 
-When enabled, the keep-alive visits the site's **Page visitée** at a fixed interval (5 min to 1 h), day and night, so that the session does not expire from inactivity. Each visit is also a check: if the login sign no longer appears, the site is marked **À reconnecter**, shown in the banner of the Sites page (unless disabled for that site), and the keep-alive stops visiting it until the next login. The visited page is also used by **Vérifier maintenant**.
+When enabled, the keep-alive visits the site's **Page visitée** at a fixed interval (5 min to 1 h), day and night, so that the session does not expire from inactivity. Each visit is also a check: if the login sign no longer appears, the site is marked **À reconnecter**, shown in the banner of the Sites page (unless disabled for that site), and the keep-alive stops visiting it until the next login. The visited page is also used by **Vérifier maintenant**. Each check is bounded in time (navigation timeout, plus the wait for the sign and a margin), and the keep-alive checks every site on its own: a site that fails, hangs or must be reconnected never stops the others from being checked.
 
 The keep-alive cannot prevent a logout the site imposes on its own schedule (e.g. every night): it only avoids inactivity timeouts. After such a logout, the assisted login takes a few seconds per site.
 

package/dist/capture.js

@@ -1,37 +1,60 @@
-const CAPTURE_TIMEOUT_MS = 20_000;
+import { withTimeout } from './timeout.js';
+/** Délai des captures de l'outil `screenshot`. */
+const TOOL_CAPTURE_TIMEOUT_MS = 20_000;
+/** Délai des captures de la GUI, plus court que les 5 s au bout desquelles la GUI abandonne sa requête. */
+const VIEW_CAPTURE_TIMEOUT_MS = 4_000;
 let queue = Promise.resolve();
 /**
- * Exécute une capture d'écran sur la page, une seule à la fois pour tout le
- * process, après avoir mis la page au premier plan. Chrome sans fenêtre bloque
- * la capture d'une page qui n'est pas au premier plan dès que plusieurs pages
- * sont ouvertes, et deux mises au premier plan simultanées se contrarient.
- * Une capture qui dépasse le délai échoue sans bloquer les suivantes.
+ * Exécute les captures une seule à la fois pour tout le process. Chrome sans
+ * fenêtre bloque la capture d'une page qui n'est pas au premier plan dès que
+ * plusieurs pages sont ouvertes, et deux mises au premier plan simultanées se
+ * contrarient : chaque capture met donc sa page au premier plan, seule.
  */
-export function runCapture(page, capture) {
-    const run = async () => {
-        let timer;
-        const timeout = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`Capture d'écran sans réponse après ${CAPTURE_TIMEOUT_MS / 1000} s.`)), CAPTURE_TIMEOUT_MS);
-        });
-        try {
-            return await Promise.race([
-                (async () => {
-                    await page.bringToFront();
-                    return capture();
-                })(),
-                timeout,
-            ]);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    };
+function enqueue(run) {
     const next = queue.then(run, run);
     queue = next.catch(() => undefined);
     return next;
 }
-/** Capture JPEG de la partie visible de la page, encodée en base64. */
-export async function captureJpegBase64(page, quality) {
-    const buffer = await runCapture(page, () => page.screenshot({ type: 'jpeg', quality }));
-    return Buffer.from(buffer).toString('base64');
+/**
+ * Capture de l'outil `screenshot`, avec les options de Puppeteer (élément, zone,
+ * page entière). Une capture qui dépasse le délai échoue sans retenir la file.
+ */
+export function runCapture(page, capture) {
+    return enqueue(() => withTimeout((async () => {
+        await page.bringToFront();
+        return capture();
+    })(), TOOL_CAPTURE_TIMEOUT_MS, `Capture d'écran sans réponse après ${TOOL_CAPTURE_TIMEOUT_MS / 1000} s.`));
+}
+const viewSessions = new WeakMap();
+async function viewSessionFor(page) {
+    const existing = viewSessions.get(page);
+    if (existing && !existing.detached)
+        return existing;
+    const session = await page.createCDPSession();
+    viewSessions.set(page, session);
+    return session;
+}
+/**
+ * Capture JPEG de la partie visible de la page pour la GUI, encodée en base64.
+ * Elle passe par une session CDP propre à la page plutôt que par
+ * `page.screenshot()`, dont le verrou reste pris tant qu'une capture n'a pas
+ * abouti. Après un dépassement de délai, la session est détachée et la suivante
+ * repart d'une session neuve : une capture abandonnée ne bloque rien.
+ */
+export function captureJpegBase64(page, quality) {
+    return enqueue(async () => {
+        const session = await viewSessionFor(page);
+        try {
+            return await withTimeout((async () => {
+                await session.send('Page.bringToFront');
+                const { data } = await session.send('Page.captureScreenshot', { format: 'jpeg', quality });
+                return data;
+            })(), VIEW_CAPTURE_TIMEOUT_MS, `Capture d'écran sans réponse après ${VIEW_CAPTURE_TIMEOUT_MS / 1000} s.`);
+        }
+        catch (err) {
+            viewSessions.delete(page);
+            await withTimeout(session.detach(), 1_000, 'Détachement sans réponse.').catch(() => undefined);
+            throw err;
+        }
+    });
 }

package/dist/keep-alive.js

@@ -21,6 +21,11 @@ export function nextKeepAliveAt(now = Date.now()) {
     return times.length ? Math.min(...times) : null;
 }
 let ticking = false;
+/**
+ * Vérifie, l'un après l'autre, les sites dont le passage est dû. Chaque site est
+ * traité à part : son échec n'empêche pas les suivants d'être vérifiés, et la
+ * durée bornée de chaque vérification empêche un site bloqué de figer le tour.
+ */
 async function tick() {
     if (ticking)
         return;
@@ -34,7 +39,12 @@ async function tick() {
             const next = nextVisitAt(site, now);
             if (next === null || next > now)
                 continue;
-            await checkSite(site.id);
+            try {
+                await checkSite(site.id);
+            }
+            catch (err) {
+                console.error(`[KeepAlive] ${site.name} : ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     catch (err) {

package/dist/site-check.js

@@ -1,6 +1,7 @@
 import { getBrowser, getDefaultTimeout } from './browser.js';
-import { syncJarsFromBrowser } from './cookie-sync.js';
+import { scheduleJarSync } from './cookie-sync.js';
 import { requireStore } from './site-store.js';
+import { withTimeout } from './timeout.js';
 const SELECTOR_WAIT_MS = 5_000;
 /** L'adresse, sans paramètres ni ancre, avec ou sans son port, contient la valeur attendue. */
 export function urlMatchesSignal(url, value) {
@@ -39,10 +40,20 @@ const running = new Set();
 export function isChecking(siteId) {
     return running.has(siteId);
 }
+/** Ferme la page sans attendre : une page bloquée ne doit pas retenir la vérification. */
+async function closeLater(page) {
+    await page?.close().catch(() => undefined);
+}
+/** Durée maximale d'une vérification : navigation, attente du signe et marge. */
+function checkTimeoutMs() {
+    return getDefaultTimeout() + SELECTOR_WAIT_MS + 10_000;
+}
 /**
  * Visite la page de vérification du site avec ses cookies et met à jour son
  * état : connecté si le signe de connexion apparaît, déconnecté sinon. Une
- * page injoignable laisse l'état inchangé et enregistre l'erreur.
+ * page injoignable, ou une vérification qui dépasse sa durée maximale, laisse
+ * l'état inchangé et enregistre l'erreur ; un résultat arrivé après ce délai
+ * est ignoré.
  */
 export async function checkSite(siteId) {
     const store = requireStore();
@@ -54,10 +65,17 @@ export async function checkSite(siteId) {
         return site;
     running.add(siteId);
     let page = null;
-    try {
+    let settled = false;
+    const visit = async () => {
         page = await (await getBrowser()).newPage();
+        if (settled) {
+            void closeLater(page);
+            return;
+        }
         await page.goto(site.keepAlive.pageUrl, { waitUntil: 'networkidle2', timeout: getDefaultTimeout() });
         const connected = await pageShowsSignal(page, site.signal, SELECTOR_WAIT_MS);
+        if (settled)
+            return;
         const now = Date.now();
         if (connected) {
             store.setState(siteId, { status: 'connected', lostAt: null, lastCheckAt: now, lastCheckError: null });
@@ -73,6 +91,10 @@ export async function checkSite(siteId) {
             });
             store.addEvent(siteId, 'check-lost', `redirigé vers ${describePath(page.url())}`);
         }
+    };
+    try {
+        const limit = checkTimeoutMs();
+        await withTimeout(visit(), limit, `Vérification sans réponse après ${Math.round(limit / 1000)} s.`);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -80,9 +102,10 @@ export async function checkSite(siteId) {
         store.addEvent(siteId, 'check-error', message);
     }
     finally {
-        await page?.close().catch(() => undefined);
+        settled = true;
         running.delete(siteId);
+        void closeLater(page);
     }
-    await syncJarsFromBrowser();
+    scheduleJarSync();
     return store.get(siteId);
 }

package/dist/timeout.js

@@ -0,0 +1,16 @@
+/**
+ * Résout comme `work`, ou échoue avec `message` si `work` dépasse `ms`. L'opération
+ * dépassée n'est pas interrompue : l'appelant libère lui-même ce qu'elle retient.
+ */
+export async function withTimeout(work, ms, message) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/simple-scraper",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "description": "MCP server for web scraping and JavaScript execution using Puppeteer",
   "type": "module",
   "main": "dist/index.js",