@imenam/simple-scraper 1.0.23 → 1.0.27

package/dist/index.js

@@ -9,10 +9,12 @@ import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { setupLogging } from './logger.js';
 import { getBrowser, closeBrowser, getDefaultTimeout } from './browser.js';
-import { loadAllCookies } from './cookies.js';
+import { scheduleJarSync, startPeriodicJarSync } from './cookie-sync.js';
+import { getDataDir } from './data-dir.js';
+import { startKeepAlive } from './keep-alive.js';
 import { GuiLauncher, reconnectGuiToolDefinition } from '@imenam/mcp-gui-interface';
 import { createSession, getSession, closeSession, closeAllSessions, listSessions, getSessionLogs, clearSessionLogs, resolveViewport } from './sessions.js';
-import { registerSessionRpc } from './session-rpc.js';
+import { registerRpc } from './rpc.js';
 import { deliverFile, RELAY_SHAPE_DESCRIPTIONS } from './relay.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(__dirname, '..');
@@ -62,22 +64,6 @@ function toViewportOverride(v) {
         return undefined;
     return { width: v.width, height: v.height, deviceScaleFactor: v.device_scale_factor };
 }
-// ─── One-shot helpers ─────────────────────────────────────────────────────────
-async function setCookies(page, cookies, pageUrl) {
-    const prepared = cookies.map(c => {
-        if (!c.domain) {
-            return { ...c, url: pageUrl };
-        }
-        return c;
-    });
-    await page.setCookie(...prepared);
-}
-async function applyCookies(page, pageUrl) {
-    const cookies = await loadAllCookies();
-    if (cookies.length) {
-        await setCookies(page, cookies, pageUrl);
-    }
-}
 // ─── Page-level helpers (shared between one-shot and session tools) ───────────
 async function extractInputs(page, opts) {
     return page.evaluate(({ selector: sel, showHidden }) => {
@@ -211,7 +197,6 @@ server.tool('scrape_page', 'Navigate to a URL using a headless browser and retur
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -225,6 +210,7 @@ server.tool('scrape_page', 'Navigate to a URL using a headless browser and retur
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── reconnect_gui ──────────────────────────────────────────────────────────────
@@ -250,7 +236,6 @@ server.tool('execute_js', 'Navigate to a URL and execute custom JavaScript in th
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -269,6 +254,7 @@ server.tool('execute_js', 'Navigate to a URL and execute custom JavaScript in th
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── get_page_inputs ──────────────────────────────────────────────────────────
@@ -286,7 +272,7 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     }
     if (session_id) {
         try {
-            const page = getSession(session_id);
+            const page = getSession(session_id, 'get_page_inputs');
             const result = await extractInputs(page, { selector, showHidden: show_hidden ?? false });
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
@@ -298,7 +284,6 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -312,6 +297,7 @@ server.tool('get_page_inputs', 'Return a structured JSON object of all form inpu
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── get_show_page ────────────────────────────────────────────────────────────
@@ -333,7 +319,6 @@ server.tool('get_show_page', 'Navigate to a URL and automatically parse a show/d
     const browser = await getBrowser();
     const page = await browser.newPage();
     try {
-        await applyCookies(page, url);
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -351,6 +336,7 @@ server.tool('get_show_page', 'Navigate to a URL and automatically parse a show/d
     }
     finally {
         await page.close();
+        scheduleJarSync();
     }
 });
 // ─── open_session ─────────────────────────────────────────────────────────────
@@ -400,7 +386,7 @@ server.tool('session_goto', 'Navigate the browser session to a new URL without c
 }, async ({ session_id, url, wait_for, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_goto');
         await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -420,7 +406,7 @@ server.tool('session_click', 'Click on an element in the browser session identif
 }, async ({ session_id, selector, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_click');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         await page.click(selector);
         return { content: [{ type: 'text', text: `Clicked "${selector}"` }] };
@@ -440,7 +426,7 @@ server.tool('session_type', 'Type text into an input element in the browser sess
 }, async ({ session_id, selector, text, clear, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_type');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         if (clear) {
             await page.click(selector, { clickCount: 3 });
@@ -461,7 +447,7 @@ server.tool('session_wait_for', 'Wait for a CSS selector to appear in the active
 }, async ({ session_id, selector, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_wait_for');
         await page.waitForSelector(selector, { timeout: effectiveTimeout });
         return { content: [{ type: 'text', text: `Selector "${selector}" found.` }] };
     }
@@ -479,7 +465,7 @@ server.tool('session_evaluate', 'Execute custom JavaScript in the context of an
 }, async ({ session_id, script, wait_for, timeout }) => {
     const effectiveTimeout = timeout ?? getDefaultTimeout();
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_evaluate');
         if (wait_for) {
             await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
         }
@@ -501,7 +487,7 @@ server.tool('session_html', 'Return the current full rendered HTML of an active
     session_id: z.string().describe('Session ID returned by open_session'),
 }, async ({ session_id }) => {
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_html');
         const html = await page.content();
         return { content: [{ type: 'text', text: html }] };
     }
@@ -517,7 +503,7 @@ server.tool('session_query_selector', 'Query the active session page with a CSS
     limit: z.number().optional().describe('Max number of elements to return (default: 10)'),
 }, async ({ session_id, selector, limit }) => {
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_query_selector');
         const results = await page.$$eval(selector, (elements, maxItems) => elements.slice(0, maxItems).map(el => {
             const text = (el.textContent ?? '').trim().slice(0, 100);
             return {
@@ -566,7 +552,7 @@ server.tool('session_scroll', 'Scroll the active session page. Use selector to s
         return { content: [{ type: 'text', text: 'Error: provide at least one of selector, to_bottom, x, or y.' }], isError: true };
     }
     try {
-        const page = getSession(session_id);
+        const page = getSession(session_id, 'session_scroll');
         if (selector) {
             await page.$eval(selector, el => el.scrollIntoView());
             return { content: [{ type: 'text', text: `Scrolled "${selector}" into view.` }] };
@@ -606,7 +592,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     destination_path: z
         .string()
         .optional()
-        .describe(`${RELAY_SHAPE_DESCRIPTIONS.destination_path}. Required when output is "file" or "both"`),
+        .describe(`${RELAY_SHAPE_DESCRIPTIONS.destination_path}. Required when output is "file" or "both", except behind the mcp-http-gateway relay, which keeps it on the agent side`),
     filename: z
         .string()
         .optional()
@@ -623,10 +609,17 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     // Écrire un fichier suppose de savoir où, et sur quelle machine. Il n'y a pas de
     // destination par défaut : elle atterrirait sur le disque de ce serveur, qui n'est
     // pas forcément celui de l'agent — un fichier introuvable plutôt qu'une erreur.
+    // Derrière le relais, la destination reste côté agent : seul le nom du fichier arrive ici.
     const wantsFile = output === 'file' || output === 'both';
-    if (wantsFile && (!destination_path || !filename)) {
+    if (wantsFile && !filename) {
+        return {
+            content: [{ type: 'text', text: 'Error: filename is required when output is "file" or "both".' }],
+            isError: true,
+        };
+    }
+    if (wantsFile && !destination_relay && !destination_path) {
         return {
-            content: [{ type: 'text', text: 'Error: destination_path and filename are required when output is "file" or "both".' }],
+            content: [{ type: 'text', text: 'Error: destination_path is required when output is "file" or "both".' }],
             isError: true,
         };
     }
@@ -636,7 +629,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     let previousViewport;
     try {
         if (session_id) {
-            page = getSession(session_id);
+            page = getSession(session_id, 'screenshot');
             if (viewport) {
                 previousViewport = page.viewport();
                 await page.setViewport(resolveViewport(toViewportOverride(viewport)));
@@ -652,7 +645,6 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
             if (viewport) {
                 await page.setViewport(resolveViewport(toViewportOverride(viewport)));
             }
-            await applyCookies(page, url);
             await page.goto(url, { waitUntil: 'networkidle2', timeout: effectiveTimeout });
             if (wait_for) {
                 await page.waitForSelector(wait_for, { timeout: effectiveTimeout });
@@ -681,7 +673,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
         }
         if (wantsFile) {
             resultContent.push(...deliverFile(imageBuffer, mimeType, {
-                destination_path: destination_path,
+                destination_path,
                 filename: filename,
                 destination_overwrite,
                 destination_relay,
@@ -696,6 +688,7 @@ server.tool('screenshot', 'Take a screenshot of a page. Provide either session_i
     finally {
         if (ownedPage && page) {
             await page.close();
+            scheduleJarSync();
         }
         else if (page && previousViewport) {
             await page.setViewport(previousViewport).catch(() => undefined);
@@ -708,15 +701,20 @@ function launchGUI() {
         return;
     }
     launcher.start();
-    registerSessionRpc(launcher);
+    registerRpc(launcher);
 }
 async function main() {
+    // Un dossier de données mal configuré arrête le serveur avant qu'aucun outil ne serve.
+    const dataDir = getDataDir();
+    console.error(`[MCP] Dossier des sites : ${dataDir ?? 'non configuré (sites désactivés)'}`);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('[MCP] Simple Scraper MCP server started');
     // Après le connect, comme mcp-documentor : au redémarrage du serveur par le
     // client, le master sortant a alors eu le temps de libérer la route.
     launchGUI();
+    startKeepAlive();
+    startPeriodicJarSync();
 }
 main().catch(async (err) => {
     console.error('[MCP] Fatal error:', err);

package/dist/keep-alive.js

@@ -0,0 +1,51 @@
+import { checkSite } from './site-check.js';
+import { getStore } from './site-store.js';
+const TICK_MS = 60_000;
+/** Le maintien visite ce site : activé, avec une page de vérification, et pas déjà déconnecté. */
+function isMaintained(site) {
+    return site.keepAlive.enabled && !!site.keepAlive.pageUrl && site.state.status !== 'disconnected';
+}
+/** Prochaine visite du maintien pour ce site, ou null s'il n'en fait pas. */
+export function nextVisitAt(site, now = Date.now()) {
+    if (!isMaintained(site))
+        return null;
+    const { lastCheckAt } = site.state;
+    return lastCheckAt ? Math.max(now, lastCheckAt + site.keepAlive.intervalMin * 60_000) : now;
+}
+/** Prochaine visite du maintien, tous sites confondus. */
+export function nextKeepAliveAt(now = Date.now()) {
+    const store = getStore();
+    if (!store)
+        return null;
+    const times = store.list().map(s => nextVisitAt(s, now)).filter((t) => t !== null);
+    return times.length ? Math.min(...times) : null;
+}
+let ticking = false;
+async function tick() {
+    if (ticking)
+        return;
+    ticking = true;
+    try {
+        const store = getStore();
+        if (!store)
+            return;
+        const now = Date.now();
+        for (const site of store.list()) {
+            const next = nextVisitAt(site, now);
+            if (next === null || next > now)
+                continue;
+            await checkSite(site.id);
+        }
+    }
+    catch (err) {
+        console.error(`[KeepAlive] ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        ticking = false;
+    }
+}
+/** Démarre le maintien : chaque minute, visite les sites dont le passage est dû. */
+export function startKeepAlive() {
+    setInterval(() => void tick(), TICK_MS).unref();
+    setTimeout(() => void tick(), 10_000).unref();
+}

package/dist/login.js

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import puppeteer from 'puppeteer';
+import { replaceSiteCookies } from './cookie-sync.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. */
+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 teardown(login) {
+    clearInterval(login.timer);
+    await login.browser.close().catch(() => undefined);
+    fs.rmSync(login.profileDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+}
+function settle(login, patch) {
+    login.status = { ...login.status, ...patch };
+    last = login.status;
+    if (active === login)
+        active = null;
+}
+/** Récupère les cookies de la fenêtre de connexion et les enregistre pour le site. */
+async function finish(login) {
+    if (login.status.phase !== 'waiting')
+        return;
+    login.status.phase = 'saving';
+    clearInterval(login.timer);
+    try {
+        const cookies = await login.browser.cookies();
+        if (!cookies.length)
+            throw new Error('La fenêtre de connexion ne contient aucun cookie.');
+        const count = await replaceSiteCookies(login.status.siteId, cookies);
+        const store = requireStore();
+        const now = Date.now();
+        store.setState(login.status.siteId, {
+            status: 'connected',
+            sessionOpenedAt: now,
+            lostAt: null,
+            lastCheckAt: now,
+            lastCheckError: null,
+        });
+        store.addEvent(login.status.siteId, 'login', cookieCountLabel(count, 'enregistré'));
+        settle(login, { phase: 'done', cookieCount: count });
+    }
+    catch (err) {
+        settle(login, { phase: 'error', error: err instanceof Error ? err.message : String(err) });
+    }
+    await teardown(login);
+}
+/** Surveille la fenêtre : connexion terminée quand le signe du site apparaît. */
+async function poll(login) {
+    if (login.status.phase !== 'waiting')
+        return;
+    if (!login.browser.connected) {
+        settle(login, { phase: 'cancelled' });
+        await teardown(login);
+        return;
+    }
+    const page = await currentPage(login.browser).catch(() => null);
+    if (!page)
+        return;
+    login.status.url = page.url();
+    const site = requireStore().get(login.status.siteId);
+    const signalled = await pageShowsSignal(page, site.signal).catch(() => false);
+    if (signalled)
+        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.
+ */
+export async function startLogin(siteId) {
+    if (active)
+        throw new Error('Une connexion est déjà en cours.');
+    const site = requireStore().get(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 page = (await browser.pages())[0] ?? (await browser.newPage());
+    const login = {
+        status: { siteId, phase: 'waiting', url: site.loginUrl, error: null, cookieCount: null, startedAt: Date.now() },
+        browser,
+        profileDir,
+        timer: setInterval(() => void poll(login), POLL_MS),
+    };
+    active = login;
+    last = login.status;
+    browser.on('disconnected', () => {
+        if (login.status.phase === 'waiting') {
+            settle(login, { phase: 'cancelled' });
+            void teardown(login);
+        }
+    });
+    page.goto(site.loginUrl).catch(err => {
+        if (login.status.phase !== 'waiting')
+            return;
+        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. */
+export function getLoginStatus() {
+    return active?.status ?? last;
+}
+/** Enregistre la connexion sans attendre le signe du site. */
+export async function confirmLogin() {
+    if (!active)
+        throw new Error('Aucune connexion en cours.');
+    const login = active;
+    await finish(login);
+    return login.status;
+}
+export async function cancelLogin() {
+    if (!active)
+        return;
+    const login = active;
+    settle(login, { phase: 'cancelled' });
+    await teardown(login);
+}
+/** Capture JPEG de l'onglet courant de la fenêtre 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');
+}

package/dist/relay.js

@@ -50,18 +50,22 @@ export function deliverFile(data, mimeType, target) {
         ];
     }
     // Pas de relais : le MCP tourne à côté de l'agent, son disque est le bon.
-    if (!path.isAbsolute(target.destination_path)) {
-        throw new Error(`destination_path must be an absolute directory path: ${target.destination_path}`);
+    if (!target.destination_path) {
+        throw new Error('destination_path is required when no relay delivers the file.');
     }
-    if (fs.existsSync(target.destination_path) &&
-        !fs.statSync(target.destination_path).isDirectory()) {
-        throw new Error(`destination_path must be a directory, but a file already exists there: ${target.destination_path}`);
+    const destination = target.destination_path;
+    if (!path.isAbsolute(destination)) {
+        throw new Error(`destination_path must be an absolute directory path: ${destination}`);
     }
-    const written = path.join(target.destination_path, name);
+    if (fs.existsSync(destination) &&
+        !fs.statSync(destination).isDirectory()) {
+        throw new Error(`destination_path must be a directory, but a file already exists there: ${destination}`);
+    }
+    const written = path.join(destination, name);
     if (!target.destination_overwrite && fs.existsSync(written)) {
         throw new Error(`Destination already exists: ${written}. Pass destination_overwrite to replace it.`);
     }
-    fs.mkdirSync(target.destination_path, { recursive: true });
+    fs.mkdirSync(destination, { recursive: true });
     fs.writeFileSync(written, data);
     return [{ type: "text", text: `File written to ${written} (${data.length} bytes).` }];
 }

package/dist/rpc.js

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+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 { checkSite, isChecking } from './site-check.js';
+import { cookieCountLabel, getStore, requireStore } from './site-store.js';
+import { closeAllSessions, closeSession, getSessionLogs, listSessions, peekSession } from './sessions.js';
+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() }),
+    keepAlive: z.object({
+        enabled: z.boolean(),
+        intervalMin: z.number().int().min(1).max(24 * 60),
+        pageUrl: z.union([z.literal(''), z.url('Page visitée invalide.')]),
+    }),
+    flagWhenLost: z.boolean(),
+});
+function parseSiteConfig(data) {
+    const result = siteConfigSchema.safeParse(data);
+    if (!result.success)
+        throw new Error(result.error.issues.map(i => i.message).join(' '));
+    return result.data;
+}
+/** Site enrichi de ce que l'interface affiche à côté de ses réglages. */
+function siteView(site) {
+    const store = requireStore();
+    return {
+        ...site,
+        cookieCount: store.getJar(site.id).length,
+        jarUpdatedAt: store.jarUpdated(site.id),
+        checking: isChecking(site.id),
+        nextVisitAt: nextVisitAt(site),
+    };
+}
+function sessionViews() {
+    const store = getStore();
+    return listSessions().map(s => {
+        const site = store?.siteForUrl(s.url) ?? null;
+        return { ...s, siteId: site?.id ?? null, siteName: site?.name ?? null };
+    });
+}
+/** Lance la vérification sans l'attendre : l'interface suit son avancement par l'état du site. */
+function startCheck(siteId) {
+    checkSite(siteId).catch(err => console.error(`[Sites] Vérification de ${siteId} échouée : ${err instanceof Error ? err.message : String(err)}`));
+}
+function status() {
+    let dataDir = null;
+    let error = null;
+    try {
+        dataDir = getDataDir();
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+    }
+    const sites = dataDir ? requireStore().list() : [];
+    return {
+        dataDir,
+        error,
+        lostCount: sites.filter(s => s.state.status === 'disconnected' && s.flagWhenLost).length,
+        sessionCount: listSessions().length,
+        keepAlive: {
+            maintainedCount: sites.filter(s => nextVisitAt(s) !== null).length,
+            nextAt: dataDir ? nextKeepAliveAt() : null,
+        },
+    };
+}
+const handlers = {
+    STATUS: () => status(),
+    SITES_LIST: () => requireStore().list().map(siteView),
+    SITE_GET: ({ siteId }) => siteView(requireStore().get(siteId)),
+    SITE_CREATE: ({ config }) => {
+        const site = requireStore().create(parseSiteConfig(config));
+        if (site.keepAlive.pageUrl)
+            startCheck(site.id);
+        return siteView(site);
+    },
+    SITE_UPDATE: ({ siteId, config }) => siteView(requireStore().update(siteId, parseSiteConfig(config))),
+    SITE_DELETE: async ({ siteId }) => {
+        await clearSiteCookies(siteId);
+        requireStore().remove(siteId);
+        return null;
+    },
+    SITE_CHECK: ({ siteId }) => {
+        const site = requireStore().get(siteId);
+        if (!site.keepAlive.pageUrl)
+            throw new Error(`Le site "${site.name}" n'a pas de page de vérification.`);
+        startCheck(siteId);
+        return null;
+    },
+    SITE_IMPORT_COOKIES: async ({ siteId, content }) => {
+        const cookies = parseNetscapeCookies(String(content ?? ''));
+        if (!cookies.length)
+            throw new Error('Aucun cookie au format Netscape dans ce fichier.');
+        const count = await replaceSiteCookies(siteId, cookies);
+        const store = requireStore();
+        store.setState(siteId, { status: 'unknown', sessionOpenedAt: Date.now(), lostAt: null, lastCheckError: null });
+        store.addEvent(siteId, 'import', cookieCountLabel(count, 'importé'));
+        if (store.get(siteId).keepAlive.pageUrl)
+            startCheck(siteId);
+        return siteView(store.get(siteId));
+    },
+    SITE_CLEAR_COOKIES: async ({ siteId }) => {
+        await clearSiteCookies(siteId);
+        const store = requireStore();
+        store.setState(siteId, { status: 'disconnected', sessionOpenedAt: null, lostAt: Date.now() });
+        store.addEvent(siteId, 'cleared', 'session effacée');
+        return siteView(store.get(siteId));
+    },
+    EVENTS_LIST: ({ siteId, limit }) => requireStore().listEvents({ siteId, limit }),
+    LOGIN_START: ({ siteId }) => startLogin(siteId),
+    LOGIN_STATUS: () => getLoginStatus(),
+    LOGIN_SCREENSHOT: async () => ({ base64: await loginScreenshot() }),
+    LOGIN_CONFIRM: () => confirmLogin(),
+    LOGIN_CANCEL: async () => {
+        await cancelLogin();
+        return null;
+    },
+    SESSION_LIST: () => sessionViews(),
+    SESSION_SCREENSHOT: async ({ sessionId }) => {
+        const buffer = await peekSession(sessionId).screenshot({ type: 'jpeg', quality: 60 });
+        return { base64: Buffer.from(buffer).toString('base64') };
+    },
+    SESSION_LOGS: ({ sessionId }) => getSessionLogs(sessionId),
+    SESSION_CLOSE: async ({ sessionId }) => {
+        await closeSession(sessionId);
+        return null;
+    },
+    SESSION_CLOSE_ALL: async () => {
+        await closeAllSessions();
+        return null;
+    },
+};
+/** Répond aux requêtes de la GUI, qui n'a accès ni au navigateur ni aux sites. */
+export function registerRpc(launcher) {
+    launcher.getIpcHub().onMessage(async (msg) => {
+        const handler = handlers[msg.type];
+        if (!handler)
+            return;
+        const reply = (data, error) => launcher.getIpcHub().send({
+            type: `${msg.type}_RESPONSE`,
+            correlationId: msg.correlationId,
+            data,
+            error,
+            timestamp: new Date().toISOString(),
+        });
+        try {
+            reply(await handler(msg.data ?? {}));
+        }
+        catch (err) {
+            reply(undefined, err instanceof Error ? err.message : String(err));
+        }
+    });
+}