@imenam/simple-scraper 1.0.7 → 1.0.8

package/dist/sessions.js

@@ -0,0 +1,97 @@
+import { getBrowser } from './browser.js';
+import { loadAllCookies } from './cookies.js';
+const MAX_SESSIONS = parseInt(process.env.SCRAPER_MAX_SESSIONS ?? '5', 10);
+const TTL_MS = parseInt(process.env.SCRAPER_SESSION_TTL_MS ?? String(10 * 60 * 1000), 10);
+const sessions = new Map();
+function generateSessionId() {
+    return 'sess_' + Math.random().toString(36).slice(2, 8);
+}
+async function applyCookies(page, pageUrl) {
+    const cookies = await loadAllCookies();
+    if (!cookies.length)
+        return;
+    const prepared = cookies.map(c => (c.domain ? c : { ...c, url: pageUrl }));
+    await page.setCookie(...prepared);
+}
+export async function createSession(url, opts = {}) {
+    if (sessions.size >= MAX_SESSIONS) {
+        throw new Error(`Session limit reached (max ${MAX_SESSIONS}). Close an existing session before opening a new one.`);
+    }
+    const sessionId = generateSessionId();
+    const browser = await getBrowser();
+    const page = await browser.newPage();
+    const entry = { page, createdAt: Date.now(), lastUsedAt: Date.now(), consoleLogs: [] };
+    page.on('console', (msg) => {
+        entry.consoleLogs.push({ type: msg.type(), text: msg.text(), timestamp: Date.now() });
+    });
+    try {
+        await applyCookies(page, url);
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: opts.timeout ?? 30_000 });
+        if (opts.waitFor) {
+            await page.waitForSelector(opts.waitFor, { timeout: opts.timeout ?? 30_000 });
+        }
+    }
+    catch (err) {
+        await page.close().catch(() => undefined);
+        throw err;
+    }
+    sessions.set(sessionId, entry);
+    console.error(`[Session] Created ${sessionId} → ${url}`);
+    return sessionId;
+}
+export function getSession(sessionId) {
+    const entry = sessions.get(sessionId);
+    if (!entry) {
+        throw new Error(`Session "${sessionId}" not found or already closed.`);
+    }
+    if (entry.page.isClosed()) {
+        sessions.delete(sessionId);
+        throw new Error(`Session "${sessionId}" page was closed unexpectedly.`);
+    }
+    entry.lastUsedAt = Date.now();
+    return entry.page;
+}
+export async function closeSession(sessionId) {
+    const entry = sessions.get(sessionId);
+    if (!entry)
+        return;
+    await entry.page.close().catch(() => undefined);
+    sessions.delete(sessionId);
+    console.error(`[Session] Closed ${sessionId}`);
+}
+export async function closeAllSessions() {
+    const ids = Array.from(sessions.keys());
+    for (const id of ids) {
+        await closeSession(id);
+    }
+    console.error('[Session] All sessions closed');
+}
+export function getSessionLogs(sessionId) {
+    const entry = sessions.get(sessionId);
+    if (!entry)
+        throw new Error(`Session "${sessionId}" not found or already closed.`);
+    return entry.consoleLogs;
+}
+export function clearSessionLogs(sessionId) {
+    const entry = sessions.get(sessionId);
+    if (!entry)
+        throw new Error(`Session "${sessionId}" not found or already closed.`);
+    entry.consoleLogs.length = 0;
+}
+export function listSessions() {
+    return Array.from(sessions.entries()).map(([sessionId, s]) => ({
+        sessionId,
+        createdAt: s.createdAt,
+        lastUsedAt: s.lastUsedAt,
+    }));
+}
+// GC: close sessions inactive for more than TTL_MS
+setInterval(async () => {
+    const now = Date.now();
+    for (const [id, entry] of sessions.entries()) {
+        if (now - entry.lastUsedAt > TTL_MS) {
+            console.error(`[Session] GC: closing inactive session ${id}`);
+            await closeSession(id);
+        }
+    }
+}, 60_000);

package/package.json

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