@imenam/simple-scraper 1.0.27 → 1.0.29

package/README.md

@@ -355,6 +355,8 @@ 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.
+
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `session_id` | string | | Session ID. If provided, `url` is ignored and the current page state is captured. |
@@ -396,11 +398,17 @@ A **site** is an account the scraper uses while logged in: a name, the domains i
 The sign tells the scraper whether a page is seen logged in:
 
 - **L'adresse contient** (the address contains): the page address (host and path, without query or anchor) contains the value, e.g. `crm.example.com/app`;
-- **Un élément est présent** (an element is present): a CSS selector that only exists once logged in, e.g. `#user-menu`.
+- **Un élément est présent** (an element is present): a selector that only matches once logged in, e.g. `.user-menu`. Puppeteer's extended selectors are accepted, so an element can be matched by its text: `.user-menu span::-p-text(Galadrim)`.
+
+**Choisir sur la page** opens the visited page as the scraper sees it logged in; clicking an element (your name, for instance) proposes selectors for it, from the most precise (its text inside its container) to the most general. **Tester** checks the sign as it is typed. Both check each selector twice: it must be found on the visited page with the site's cookies, and absent from the same page without cookies; a selector passing both is a reliable login sign.
 
 ### Assisted login
 
-**Se reconnecter** opens a visible Chromium window, on a blank temporary profile, at the site's login page, on the machine running the MCP. You log in there yourself (credentials, two-factor authentication, SSO). As soon as the login sign appears, the window's cookies are saved for the site and the window closes; **Je suis connecté** saves them without waiting for the sign. Credentials never go through the MCP. **Tout reconnecter** chains every site to reconnect, one after the other.
+**Se reconnecter** opens the site's login page in a headless Chromium on a blank temporary profile, on the machine running the MCP, and shows it in the GUI. You log in there yourself (credentials, two-factor authentication, SSO): clicks, typing, pasting and scrolling on the capture are replayed in the page, and the address bar allows going back or opening another address. No display is needed, so this works the same on a remote server. As soon as the login sign appears, the browser's cookies are saved for the site and it closes; **Je suis connecté** saves them without waiting for the sign. **Tout reconnecter** chains every site to reconnect, one after the other.
+
+What you type travels from the GUI to the MCP (through the proxy when the GUI is reached remotely, which should then be served over HTTPS); it is never stored. Some sites detect headless browsers and may show a captcha or refuse the login.
+
+Every browser of the scraper starts with Chromium's sandbox disabled (`--no-sandbox`): under a service account, on a Linux that restricts unprivileged user namespaces (Ubuntu 23.10+ with AppArmor), the sandbox cannot start.
 
 ### Keep-alive
 
@@ -422,9 +430,9 @@ Netscape cookie files (`.txt`) placed in this folder are not loaded. To start fr
 
 When `PROXY_URL` is set, a web interface is registered with the MCP proxy:
 
-- **Sites** — every site with its state (logged in, to reconnect, not checked), its session and its keep-alive; banner and **Tout reconnecter** when sessions are lost; assisted login with a live preview of the login window.
-- **Site page** — domains, login page, login sign, keep-alive (interval, visited page), recent activity, cookie import and **Effacer la session**.
-- **Sessions** — the sessions opened by the agent, with a live view (refreshed every 2.5 s, can be paused), the last action, the matching site and the console messages.
+- **Sites** — every site with its state (logged in, to reconnect, not checked), its session and its keep-alive; banner and **Tout reconnecter** when sessions are lost; assisted login in a remotely controlled view of the login page, which can be shown full screen.
+- **Site page** — domains, login page, login sign (picked on the page and tested), keep-alive (interval, visited page), recent activity, cookie import and **Effacer la session**.
+- **Sessions** — the sessions opened by the agent, with a live view (refresh rate selectable from 0.5 s to 10 s, 2.5 s by default; can be paused or shown full screen), the last action, the matching site and the console messages.
 - **Activity** — the history of every site, filterable by site.
 
 The interface refreshes by polling: no connection stays open.

package/dist/browser.js

@@ -29,6 +29,13 @@ export function getDefaultViewport() {
         deviceScaleFactor: envNumber('PUPPETEER_DEVICE_SCALE_FACTOR', 1),
     };
 }
+/**
+ * Arguments de lancement de tous les navigateurs du scraper. La sandbox de
+ * Chromium est désactivée : sous un compte de service, sur un Linux qui
+ * restreint les espaces de noms utilisateur (Ubuntu 23.10+ avec AppArmor),
+ * elle ne peut pas démarrer.
+ */
+export const BROWSER_LAUNCH_ARGS = ['--no-sandbox', '--disable-setuid-sandbox'];
 /** Lance le navigateur partagé et y charge les cookies de tous les sites. */
 async function launchBrowser() {
     const cookies = getStore()?.allCookies() ?? [];
@@ -36,7 +43,7 @@ async function launchBrowser() {
     const launched = await puppeteer.launch({
         headless,
         defaultViewport: getDefaultViewport(),
-        args: ['--no-sandbox', '--disable-setuid-sandbox'],
+        args: BROWSER_LAUNCH_ARGS,
     });
     if (cookies.length)
         await launched.setCookie(...cookies);

package/dist/capture.js

@@ -0,0 +1,37 @@
+const CAPTURE_TIMEOUT_MS = 20_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.
+ */
+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);
+        }
+    };
+    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');
+}

package/dist/gui.js

@@ -148,7 +148,15 @@ app.post('/api/login', (req, res) => {
 });
 app.get('/api/login', (_req, res) => forward(res, 'LOGIN_STATUS'));
 app.get('/api/login/screenshot', (_req, res) => sendJpeg(res, 'LOGIN_SCREENSHOT'));
+app.post('/api/login/input', (req, res) => forward(res, 'LOGIN_INPUT', { action: req.body.action }, 45_000));
 app.post('/api/login/confirm', (_req, res) => forward(res, 'LOGIN_CONFIRM', undefined, 15_000));
+// ─── Choix du signe de connexion ──────────────────────────────────────────────
+app.post('/api/picker', (req, res) => forward(res, 'PICKER_OPEN', { pageUrl: req.body.pageUrl }, 45_000));
+app.get('/api/picker/screenshot', (_req, res) => sendJpeg(res, 'PICKER_SCREENSHOT'));
+app.post('/api/picker/scroll', (req, res) => forward(res, 'PICKER_SCROLL', { dy: req.body.dy }));
+app.post('/api/picker/pick', (req, res) => forward(res, 'PICKER_PICK', { x: req.body.x, y: req.body.y }, 60_000));
+app.post('/api/picker/close', (_req, res) => forward(res, 'PICKER_CLOSE'));
+app.post('/api/signal/test', (req, res) => forward(res, 'SIGNAL_TEST', { pageUrl: req.body.pageUrl, signal: req.body.signal }, 75_000));
 app.post('/api/login/cancel', (_req, res) => forward(res, 'LOGIN_CANCEL', undefined, 15_000));
 // ─── Sessions ─────────────────────────────────────────────────────────────────
 app.get('/api/sessions', (_req, res) => forward(res, 'SESSION_LIST'));

package/dist/index.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { setupLogging } from './logger.js';
 import { getBrowser, closeBrowser, getDefaultTimeout } from './browser.js';
+import { runCapture } from './capture.js';
 import { scheduleJarSync, startPeriodicJarSync } from './cookie-sync.js';
 import { getDataDir } from './data-dir.js';
 import { startKeepAlive } from './keep-alive.js';
@@ -657,15 +658,15 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
             if (!element) {
                 return { content: [{ type: 'text', text: `Error: selector "${selector}" not found.` }], isError: true };
             }
-            imageBuffer = Buffer.from(await element.screenshot({ type: fmt }));
+            imageBuffer = Buffer.from(await runCapture(page, () => element.screenshot({ type: fmt })));
         }
         else if (clip) {
             // captureBeyondViewport lets the region extend past the visible area
             // without having to scroll the page first.
-            imageBuffer = Buffer.from(await page.screenshot({ type: fmt, clip, captureBeyondViewport: true }));
+            imageBuffer = Buffer.from(await runCapture(page, () => page.screenshot({ type: fmt, clip, captureBeyondViewport: true })));
         }
         else {
-            imageBuffer = Buffer.from(await page.screenshot({ type: fmt, fullPage: full_page ?? false }));
+            imageBuffer = Buffer.from(await runCapture(page, () => page.screenshot({ type: fmt, fullPage: full_page ?? false })));
         }
         const resultContent = [];
         if (output === 'inline' || output === 'both') {

package/dist/login.js

@@ -2,18 +2,29 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import puppeteer from 'puppeteer';
+import { BROWSER_LAUNCH_ARGS, getDefaultViewport } from './browser.js';
+import { captureJpegBase64 } from './capture.js';
 import { replaceSiteCookies } from './cookie-sync.js';
+import { applyRemoteAction } from './remote-input.js';
 import { pageShowsSignal } from './site-check.js';
 import { cookieCountLabel, requireStore } from './site-store.js';
 const POLL_MS = 1_000;
 let active = null;
 let last = null;
-/** Onglet le plus récent de la fenêtre de connexion. */
+/** Onglet le plus récent du navigateur de connexion. */
 async function currentPage(browser) {
     const pages = (await browser.pages()).filter(p => !p.isClosed());
     return pages.length ? pages[pages.length - 1] : null;
 }
-/** Ferme la fenêtre de connexion et supprime son profil temporaire. */
+async function requirePage() {
+    if (!active)
+        throw new Error('Aucune connexion en cours.');
+    const page = await currentPage(active.browser);
+    if (!page)
+        throw new Error('Le navigateur de connexion n\'a aucun onglet.');
+    return page;
+}
+/** Ferme le navigateur de connexion et supprime son profil temporaire. */
 async function teardown(login) {
     clearInterval(login.timer);
     await login.browser.close().catch(() => undefined);
@@ -25,7 +36,7 @@ function settle(login, patch) {
     if (active === login)
         active = null;
 }
-/** Récupère les cookies de la fenêtre de connexion et les enregistre pour le site. */
+/** Récupère les cookies du navigateur de connexion et les enregistre pour le site. */
 async function finish(login) {
     if (login.status.phase !== 'waiting')
         return;
@@ -34,7 +45,7 @@ async function finish(login) {
     try {
         const cookies = await login.browser.cookies();
         if (!cookies.length)
-            throw new Error('La fenêtre de connexion ne contient aucun cookie.');
+            throw new Error('Le navigateur de connexion ne contient aucun cookie.');
         const count = await replaceSiteCookies(login.status.siteId, cookies);
         const store = requireStore();
         const now = Date.now();
@@ -53,7 +64,7 @@ async function finish(login) {
     }
     await teardown(login);
 }
-/** Surveille la fenêtre : connexion terminée quand le signe du site apparaît. */
+/** Surveille la page : connexion terminée quand le signe du site apparaît. */
 async function poll(login) {
     if (login.status.phase !== 'waiting')
         return;
@@ -72,9 +83,10 @@ async function poll(login) {
         await finish(login);
 }
 /**
- * Ouvre une fenêtre de navigateur visible, sur un profil vierge, à la page de
- * connexion du site. L'utilisateur s'y connecte lui-même ; ses cookies sont
- * enregistrés pour le site dès que le signe de connexion apparaît.
+ * Ouvre un navigateur sans fenêtre, sur un profil vierge, à la page de connexion
+ * du site. L'utilisateur s'y connecte depuis l'interface, qui affiche la page et
+ * lui relaie ses clics et sa frappe ; aucun écran n'est nécessaire. Les cookies
+ * sont enregistrés pour le site dès que le signe de connexion apparaît.
  */
 export async function startLogin(siteId) {
     if (active)
@@ -83,7 +95,12 @@ export async function startLogin(siteId) {
     if (!site.loginUrl)
         throw new Error(`Le site "${site.name}" n'a pas de page de connexion.`);
     const profileDir = fs.mkdtempSync(path.join(os.tmpdir(), 'simple-scraper-login-'));
-    const browser = await puppeteer.launch({ headless: false, defaultViewport: null, userDataDir: profileDir });
+    const browser = await puppeteer.launch({
+        headless: true,
+        defaultViewport: getDefaultViewport(),
+        userDataDir: profileDir,
+        args: BROWSER_LAUNCH_ARGS,
+    });
     const page = (await browser.pages())[0] ?? (await browser.newPage());
     const login = {
         status: { siteId, phase: 'waiting', url: site.loginUrl, error: null, cookieCount: null, startedAt: Date.now() },
@@ -105,7 +122,6 @@ export async function startLogin(siteId) {
         settle(login, { phase: 'error', error: err instanceof Error ? err.message : String(err) });
         void teardown(login);
     });
-    await page.bringToFront();
     return login.status;
 }
 /** Connexion en cours, ou la dernière terminée. */
@@ -127,13 +143,14 @@ export async function cancelLogin() {
     settle(login, { phase: 'cancelled' });
     await teardown(login);
 }
-/** Capture JPEG de l'onglet courant de la fenêtre de connexion. */
+/** Rejoue dans la page de connexion un clic, une frappe ou une navigation de l'utilisateur. */
+export async function loginInput(action) {
+    const page = await requirePage();
+    await applyRemoteAction(page, action);
+    if (active)
+        active.status.url = page.url();
+}
+/** Capture JPEG de l'onglet courant du navigateur de connexion. */
 export async function loginScreenshot() {
-    if (!active)
-        throw new Error('Aucune connexion en cours.');
-    const page = await currentPage(active.browser);
-    if (!page)
-        throw new Error('La fenêtre de connexion n\'a aucun onglet.');
-    const buffer = await page.screenshot({ type: 'jpeg', quality: 60 });
-    return Buffer.from(buffer).toString('base64');
+    return captureJpegBase64(await requirePage(), 70);
 }

package/dist/remote-input.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { getDefaultTimeout } from './browser.js';
+/**
+ * Action de l'utilisateur sur une page affichée dans l'interface. Les
+ * coordonnées d'un clic sont des fractions (0 à 1) de la capture, donc
+ * indépendantes de la taille à laquelle l'interface l'affiche.
+ */
+export const remoteActionSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('click'), x: z.number().min(0).max(1), y: z.number().min(0).max(1) }),
+    z.object({ type: z.literal('scroll'), dy: z.number().min(-5000).max(5000) }),
+    z.object({ type: z.literal('text'), text: z.string().min(1).max(2000) }),
+    z.object({
+        type: z.literal('key'),
+        key: z.string().min(1).max(32),
+        modifiers: z.array(z.enum(['Control', 'Shift', 'Alt', 'Meta'])).optional(),
+    }),
+    z.object({ type: z.literal('navigate'), url: z.url() }),
+    z.object({ type: z.literal('back') }),
+]);
+export function parseRemoteAction(data) {
+    const result = remoteActionSchema.safeParse(data);
+    if (!result.success)
+        throw new Error(`Action invalide : ${result.error.issues.map(i => i.message).join(' ')}`);
+    return result.data;
+}
+/** Point de la page, en pixels CSS, désigné par des fractions de sa capture. */
+export function pointOf(page, x, y) {
+    const viewport = page.viewport();
+    if (!viewport)
+        throw new Error('La page n\'a pas de taille d\'affichage fixe.');
+    return { x: x * viewport.width, y: y * viewport.height };
+}
+/** Rejoue l'action dans la page. */
+export async function applyRemoteAction(page, action) {
+    switch (action.type) {
+        case 'click': {
+            const point = pointOf(page, action.x, action.y);
+            await page.mouse.click(point.x, point.y);
+            return;
+        }
+        case 'scroll':
+            await page.mouse.wheel({ deltaY: action.dy });
+            return;
+        case 'text':
+            await page.keyboard.type(action.text);
+            return;
+        case 'key': {
+            const modifiers = action.modifiers ?? [];
+            for (const m of modifiers)
+                await page.keyboard.down(m);
+            try {
+                await page.keyboard.press(action.key);
+            }
+            finally {
+                for (const m of modifiers.slice().reverse())
+                    await page.keyboard.up(m);
+            }
+            return;
+        }
+        case 'navigate':
+            await page.goto(action.url, { waitUntil: 'domcontentloaded', timeout: getDefaultTimeout() });
+            return;
+        case 'back':
+            await page.goBack({ waitUntil: 'domcontentloaded', timeout: getDefaultTimeout() });
+            return;
+    }
+}

package/dist/rpc.js

@@ -1,19 +1,23 @@
 import { z } from 'zod';
+import { captureJpegBase64 } from './capture.js';
 import { clearSiteCookies, replaceSiteCookies } from './cookie-sync.js';
 import { parseNetscapeCookies } from './cookies.js';
 import { getDataDir } from './data-dir.js';
 import { nextKeepAliveAt, nextVisitAt } from './keep-alive.js';
-import { cancelLogin, confirmLogin, getLoginStatus, loginScreenshot, startLogin } from './login.js';
+import { cancelLogin, confirmLogin, getLoginStatus, loginInput, loginScreenshot, startLogin } from './login.js';
+import { parseRemoteAction } from './remote-input.js';
+import { closePicker, openPicker, pickAt, pickerScreenshot, pickerScroll, testSignal } from './signal-picker.js';
 import { checkSite, isChecking } from './site-check.js';
 import { cookieCountLabel, getStore, requireStore } from './site-store.js';
 import { closeAllSessions, closeSession, getSessionLogs, listSessions, peekSession } from './sessions.js';
+const signalSchema = z.object({ kind: z.enum(['url', 'selector']), value: z.string().trim() });
 const siteConfigSchema = z.object({
     name: z.string().trim().min(1, 'Le nom est requis.'),
     domains: z
         .array(z.string().trim().toLowerCase().regex(/^[a-z0-9.-]+$/, 'Domaine invalide.'))
         .min(1, 'Au moins un domaine est requis.'),
     loginUrl: z.union([z.literal(''), z.url('Page de connexion invalide.')]),
-    signal: z.object({ kind: z.enum(['url', 'selector']), value: z.string().trim() }),
+    signal: signalSchema,
     keepAlive: z.object({
         enabled: z.boolean(),
         intervalMin: z.number().int().min(1).max(24 * 60),
@@ -21,12 +25,18 @@ const siteConfigSchema = z.object({
     }),
     flagWhenLost: z.boolean(),
 });
-function parseSiteConfig(data) {
-    const result = siteConfigSchema.safeParse(data);
+/** Valide une donnée de la GUI ; l'erreur reprend les messages du schéma. */
+function parse(schema, data) {
+    const result = schema.safeParse(data);
     if (!result.success)
         throw new Error(result.error.issues.map(i => i.message).join(' '));
     return result.data;
 }
+const pageUrlSchema = z.url('Page visitée invalide.');
+const ratioSchema = z.number().min(0).max(1);
+function parseSiteConfig(data) {
+    return parse(siteConfigSchema, data);
+}
 /** Site enrichi de ce que l'interface affiche à côté de ses réglages. */
 function siteView(site) {
     const store = requireStore();
@@ -116,15 +126,30 @@ const handlers = {
     LOGIN_START: ({ siteId }) => startLogin(siteId),
     LOGIN_STATUS: () => getLoginStatus(),
     LOGIN_SCREENSHOT: async () => ({ base64: await loginScreenshot() }),
+    LOGIN_INPUT: async ({ action }) => {
+        await loginInput(parseRemoteAction(action));
+        return getLoginStatus();
+    },
     LOGIN_CONFIRM: () => confirmLogin(),
     LOGIN_CANCEL: async () => {
         await cancelLogin();
         return null;
     },
+    PICKER_OPEN: ({ pageUrl }) => openPicker(parse(pageUrlSchema, pageUrl)),
+    PICKER_SCREENSHOT: async () => ({ base64: await pickerScreenshot() }),
+    PICKER_SCROLL: async ({ dy }) => {
+        await pickerScroll(parse(z.number().min(-5000).max(5000), dy));
+        return null;
+    },
+    PICKER_PICK: ({ x, y }) => pickAt(parse(ratioSchema, x), parse(ratioSchema, y)),
+    PICKER_CLOSE: async () => {
+        await closePicker();
+        return null;
+    },
+    SIGNAL_TEST: ({ pageUrl, signal }) => testSignal(parse(pageUrlSchema, pageUrl), parse(signalSchema, signal)),
     SESSION_LIST: () => sessionViews(),
     SESSION_SCREENSHOT: async ({ sessionId }) => {
-        const buffer = await peekSession(sessionId).screenshot({ type: 'jpeg', quality: 60 });
-        return { base64: Buffer.from(buffer).toString('base64') };
+        return { base64: await captureJpegBase64(peekSession(sessionId), 60) };
     },
     SESSION_LOGS: ({ sessionId }) => getSessionLogs(sessionId),
     SESSION_CLOSE: async ({ sessionId }) => {

package/dist/signal-picker.js

@@ -0,0 +1,144 @@
+import { getBrowser, getDefaultTimeout } from './browser.js';
+import { captureJpegBase64 } from './capture.js';
+import { applyRemoteAction, pointOf } from './remote-input.js';
+import { pageShowsSignal, urlMatchesSignal } from './site-check.js';
+const SIGNAL_WAIT_MS = 3_000;
+let picker = null;
+function requirePicker() {
+    if (!picker || picker.page.isClosed())
+        throw new Error('Aucune page ouverte pour choisir le signe de connexion.');
+    return picker;
+}
+/** Ouvre la page visitée du site dans le navigateur partagé, donc avec les cookies des sites. */
+export async function openPicker(pageUrl) {
+    await closePicker();
+    const page = await (await getBrowser()).newPage();
+    picker = { page, pageUrl };
+    await page.goto(pageUrl, { waitUntil: 'networkidle2', timeout: getDefaultTimeout() });
+    return { url: page.url() };
+}
+export async function closePicker() {
+    const current = picker;
+    picker = null;
+    await current?.page.close().catch(() => undefined);
+}
+export async function pickerScreenshot() {
+    return captureJpegBase64(requirePicker().page, 70);
+}
+/** Fait défiler la page du sélecteur ; seul le défilement y est relayé. */
+export async function pickerScroll(dy) {
+    const action = { type: 'scroll', dy };
+    await applyRemoteAction(requirePicker().page, action);
+}
+/**
+ * Sélecteurs désignant l'élément situé au point donné, du plus précis au plus
+ * général : son texte dans son conteneur repérable, son chemin depuis ce
+ * conteneur, le conteneur seul, l'élément seul.
+ */
+function candidatesAt(x, y) {
+    const target = document.elementFromPoint(x, y);
+    if (!target)
+        return [];
+    const stable = (name) => /^[a-zA-Z_][\w-]*$/.test(name) &&
+        !/\d{3,}/.test(name) &&
+        !/^(active|open|show|hover|focus|focused|in|collapsed|selected|disabled|is-|has-|ng-)/.test(name);
+    const count = (selector) => document.querySelectorAll(selector).length;
+    /** Classe stable de l'élément la plus rare dans la page ; à égalité, la plus longue, souvent la plus parlante. */
+    const ownClass = (el) => Array.from(el.classList)
+        .filter(stable)
+        .sort((a, b) => count(`.${CSS.escape(a)}`) - count(`.${CSS.escape(b)}`) || b.length - a.length)[0];
+    const selfSel = (el) => {
+        if (el.id && stable(el.id))
+            return `#${CSS.escape(el.id)}`;
+        const cls = ownClass(el);
+        return cls ? `.${CSS.escape(cls)}` : null;
+    };
+    const part = (el) => {
+        if (el.id && stable(el.id))
+            return `#${CSS.escape(el.id)}`;
+        const cls = ownClass(el);
+        return el.tagName.toLowerCase() + (cls ? `.${CSS.escape(cls)}` : '');
+    };
+    // Conteneur : l'ancêtre repérable le plus proche qui soit unique dans la page,
+    // sinon le plus proche repérable.
+    let anchorSel = null;
+    let firstSel = null;
+    for (let el = target.parentElement, depth = 0; el && depth < 6; el = el.parentElement, depth++) {
+        if (el === document.body || el === document.documentElement)
+            break;
+        const sel = selfSel(el);
+        if (!sel)
+            continue;
+        firstSel ??= sel;
+        if (count(sel) === 1) {
+            anchorSel = sel;
+            break;
+        }
+    }
+    anchorSel ??= firstSel;
+    const targetSel = part(target);
+    const scoped = anchorSel ? `${anchorSel} ${targetSel}` : targetSel;
+    const out = [];
+    const text = (target.textContent ?? '').replace(/\s+/g, ' ').trim();
+    if (text && text.length <= 60 && target.children.length === 0) {
+        const quoted = JSON.stringify(text);
+        out.push({ selector: `${scoped}::-p-text(${quoted})`, label: `Le texte « ${text} » à cet endroit` });
+    }
+    if (anchorSel)
+        out.push({ selector: scoped, label: 'Cet élément, dans son conteneur' });
+    if (anchorSel)
+        out.push({ selector: anchorSel, label: 'Son conteneur' });
+    out.push({ selector: targetSel, label: 'Cet élément, n\'importe où dans la page' });
+    return out.filter((c, i) => out.findIndex(o => o.selector === c.selector) === i);
+}
+/** Ouvre la page dans un contexte sans cookies, comme la verrait une session perdue. */
+async function withAnonymousPage(pageUrl, fn) {
+    const context = await (await getBrowser()).createBrowserContext();
+    try {
+        const page = await context.newPage();
+        await page.goto(pageUrl, { waitUntil: 'networkidle2', timeout: getDefaultTimeout() });
+        return await fn(page);
+    }
+    finally {
+        await context.close().catch(() => undefined);
+    }
+}
+async function countMatches(page, selector) {
+    return (await page.$$(selector).catch(() => [])).length;
+}
+/**
+ * Propose les sélecteurs de l'élément cliqué, chacun compté sur la page vue
+ * connectée et sur la même page vue sans cookies. Un bon signe de connexion est
+ * trouvé dans le premier cas et absent dans le second ; ceux-là viennent en tête.
+ */
+export async function pickAt(x, y) {
+    const { page, pageUrl } = requirePicker();
+    const point = pointOf(page, x, y);
+    const proposals = await page.evaluate(candidatesAt, point.x, point.y);
+    if (!proposals.length)
+        return [];
+    const connected = await Promise.all(proposals.map(p => countMatches(page, p.selector)));
+    const anonymous = await withAnonymousPage(pageUrl, anon => Promise.all(proposals.map(p => countMatches(anon, p.selector))));
+    const results = proposals.map((p, i) => ({ ...p, connected: connected[i], anonymous: anonymous[i] }));
+    const good = (c) => c.connected > 0 && c.anonymous === 0;
+    return [...results.filter(good), ...results.filter(c => !good(c))];
+}
+/** Vérifie le signe sur la page vue connectée (attendu : trouvé) et sans cookies (attendu : absent). */
+export async function testSignal(pageUrl, signal) {
+    const page = await (await getBrowser()).newPage();
+    let connected;
+    let connectedUrl;
+    try {
+        await page.goto(pageUrl, { waitUntil: 'networkidle2', timeout: getDefaultTimeout() });
+        connectedUrl = page.url();
+        connected = await pageShowsSignal(page, signal, SIGNAL_WAIT_MS);
+    }
+    finally {
+        await page.close().catch(() => undefined);
+    }
+    const anon = await withAnonymousPage(pageUrl, async (p) => ({
+        url: p.url(),
+        shown: signal.kind === 'url' ? urlMatchesSignal(p.url(), signal.value) : await pageShowsSignal(p, signal),
+    }));
+    return { connected, anonymous: anon.shown, connectedUrl, anonymousUrl: anon.url };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/simple-scraper",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "MCP server for web scraping and JavaScript execution using Puppeteer",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,8 @@
     "dev:server": "tsx src/index.ts",
     "dev:gui": "cd public && npx vite",
     "prepublishOnly": "npm run build",
-    "release": "npm version patch && npm run build && npm publish --access public && git push origin master --follow-tags"
+    "release": "npm version patch && npm run build && npm publish --access public && git push origin master --follow-tags",
+    "prebuild": "node scripts/clean-dist.mjs"
   },
   "keywords": [
     "mcp",