leapfrog-mcp 0.6.2 → 0.6.3

package/dist/cdp-connector.js

@@ -0,0 +1,176 @@
+// ─── CDP Connector ─────────────────────────────────────────────────────────
+//
+// Connects Leapfrog to an already-running Chrome instance via CDP.
+// User launches Chrome with --remote-debugging-port=9222, and Leapfrog
+// attaches to use real cookies, extensions, and OAuth tokens.
+import { chromium } from "playwright-core";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as http from "http";
+import { logger } from "./logger.js";
+function getPortFileEntries() {
+    const home = os.homedir();
+    const platform = os.platform();
+    if (platform === "darwin") {
+        const base = path.join(home, "Library", "Application Support");
+        return [
+            { path: path.join(base, "Google", "Chrome", "DevToolsActivePort"), browser: "Chrome" },
+            { path: path.join(base, "Google", "Chrome Canary", "DevToolsActivePort"), browser: "Canary" },
+            { path: path.join(base, "BraveSoftware", "Brave-Browser", "DevToolsActivePort"), browser: "Brave" },
+            { path: path.join(base, "Chromium", "DevToolsActivePort"), browser: "Chromium" },
+        ];
+    }
+    if (platform === "linux") {
+        return [
+            { path: path.join(home, ".config", "google-chrome", "DevToolsActivePort"), browser: "Chrome" },
+            { path: path.join(home, ".config", "google-chrome-canary", "DevToolsActivePort"), browser: "Canary" },
+            { path: path.join(home, ".config", "BraveSoftware", "Brave-Browser", "DevToolsActivePort"), browser: "Brave" },
+            { path: path.join(home, ".config", "chromium", "DevToolsActivePort"), browser: "Chromium" },
+        ];
+    }
+    if (platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
+        return [
+            { path: path.join(localAppData, "Google", "Chrome", "User Data", "DevToolsActivePort"), browser: "Chrome" },
+            { path: path.join(localAppData, "Google", "Chrome SxS", "User Data", "DevToolsActivePort"), browser: "Canary" },
+            { path: path.join(localAppData, "BraveSoftware", "Brave-Browser", "User Data", "DevToolsActivePort"), browser: "Brave" },
+            { path: path.join(localAppData, "Chromium", "User Data", "DevToolsActivePort"), browser: "Chromium" },
+        ];
+    }
+    return [];
+}
+// ─── Helpers ───────────────────────────────────────────────────────────────
+/** Parse DevToolsActivePort file: line 1 = port, line 2 = path */
+export function parseDevToolsActivePort(contents) {
+    const lines = contents.trim().split("\n");
+    if (lines.length < 1)
+        return null;
+    const port = parseInt(lines[0].trim(), 10);
+    return Number.isFinite(port) && port > 0 && port < 65536 ? port : null;
+}
+/** Probe a single port via HTTP GET /json/version with a tight timeout */
+export function probePort(port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        const req = http.get({ hostname: "127.0.0.1", port, path: "/json/version", timeout: timeoutMs }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => { body += chunk.toString(); });
+            res.on("end", () => {
+                try {
+                    const json = JSON.parse(body);
+                    resolve(json.Browser ?? "Chrome");
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("error", () => resolve(null));
+        req.on("timeout", () => { req.destroy(); resolve(null); });
+    });
+}
+// ─── CDP Connector ─────────────────────────────────────────────────────────
+const SCAN_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
+export class CdpConnector {
+    /**
+     * Discover available CDP endpoints on this machine.
+     * Checks env var, DevToolsActivePort files, and scans common ports in parallel.
+     * Total time target: <2s.
+     */
+    static async discover() {
+        const results = [];
+        // 1. Environment variable — highest priority
+        const envEndpoint = process.env.LEAP_CDP_ENDPOINT;
+        if (envEndpoint) {
+            results.push({ endpoint: envEndpoint, browser: "Chrome", source: "env" });
+        }
+        // 2. Run port-file checks and port scans in parallel
+        const [portFileResults, portScanResults] = await Promise.all([
+            CdpConnector.discoverFromPortFiles(),
+            CdpConnector.discoverFromPortScan(),
+        ]);
+        results.push(...portFileResults, ...portScanResults);
+        // Deduplicate by endpoint
+        const seen = new Set();
+        const deduped = [];
+        for (const r of results) {
+            const key = r.endpoint.replace(/\/$/, "");
+            if (!seen.has(key)) {
+                seen.add(key);
+                deduped.push(r);
+            }
+        }
+        logger.debug("cdp.discover", { found: deduped.length });
+        return deduped;
+    }
+    /** Check all known DevToolsActivePort file locations */
+    static async discoverFromPortFiles() {
+        const entries = getPortFileEntries();
+        const results = [];
+        const checks = entries.map(async (entry) => {
+            try {
+                const contents = await fs.readFile(entry.path, "utf-8");
+                const port = parseDevToolsActivePort(contents);
+                if (port) {
+                    results.push({
+                        endpoint: `http://localhost:${port}`,
+                        browser: entry.browser,
+                        source: "devtools-port-file",
+                    });
+                }
+            }
+            catch {
+                // File doesn't exist or isn't readable — expected
+            }
+        });
+        await Promise.all(checks);
+        return results;
+    }
+    /** Scan common debug ports (9222-9229) for active CDP endpoints */
+    static async discoverFromPortScan() {
+        const results = [];
+        const probes = SCAN_PORTS.map(async (port) => {
+            const browserName = await probePort(port);
+            if (browserName) {
+                results.push({
+                    endpoint: `http://localhost:${port}`,
+                    browser: browserName,
+                    source: "port-scan",
+                });
+            }
+        });
+        await Promise.all(probes);
+        return results;
+    }
+    /** Connect to a CDP endpoint. Returns a Playwright Browser object. */
+    static async connect(endpoint) {
+        logger.info("cdp.connect", { endpoint });
+        try {
+            const browser = await chromium.connectOverCDP(endpoint);
+            logger.info("cdp.connected", { endpoint, contexts: browser.contexts().length });
+            return browser;
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            logger.error("cdp.connect_failed", { endpoint, error: msg });
+            throw new Error(`CDP connection failed to ${endpoint}: ${msg}`);
+        }
+    }
+    /**
+     * Get the best available endpoint and connect.
+     * Priority: LEAP_CDP_ENDPOINT env > DevToolsActivePort file > port scan
+     */
+    static async autoConnect() {
+        const results = await CdpConnector.discover();
+        if (results.length === 0) {
+            throw new Error("No CDP endpoint found. Launch Chrome with --remote-debugging-port=9222 " +
+                "or set LEAP_CDP_ENDPOINT environment variable.");
+        }
+        // Take the first (highest priority) result
+        const info = results[0];
+        logger.info("cdp.auto_connect", { endpoint: info.endpoint, browser: info.browser, source: info.source });
+        const browser = await CdpConnector.connect(info.endpoint);
+        return { browser, info };
+    }
+}
+export default CdpConnector;

package/dist/consent-dismiss.d.ts

@@ -0,0 +1,33 @@
+export interface ConsentFramework {
+    name: string;
+    selectors: string[];
+}
+export declare const CONSENT_SELECTORS: ConsentFramework[];
+export declare const TERMS_SELECTORS: string[];
+/**
+ * Returns JS to inject via page.evaluate() that auto-checks unchecked
+ * terms/privacy/TOS checkboxes. Only targets form checkboxes whose labels
+ * or names indicate legal agreements. Returns which selectors matched.
+ */
+export declare function getTermsAutoCheckScript(): string;
+/**
+ * Returns JS to inject via page.addInitScript().
+ * After page load + 1.5s delay, attempts to dismiss consent dialogs.
+ * Sets up a MutationObserver for lazily-loaded banners (auto-disconnects at 10s).
+ */
+export declare function getConsentDismissScript(): string;
+/**
+ * Returns JS that checks if a consent dialog is currently visible.
+ * Evaluates to `{ detected: boolean, frameworks: string[] }`.
+ */
+export declare function getConsentDetectScript(): string;
+/**
+ * Returns JS to manually trigger consent dismissal (for retry scenarios).
+ * Resets the dismissed flag so the function runs fresh.
+ */
+export declare function getManualDismissScript(): string;
+/**
+ * Returns JS to cache a successful selector for a domain.
+ * Used when the caller already knows what worked (e.g. from disk persistence).
+ */
+export declare function getCacheSelectorScript(domain: string, selector: string): string;

package/dist/consent-dismiss.js

@@ -0,0 +1,358 @@
+// ─── Consent Dismiss ──────────────────────────────────────────────────────
+//
+// Auto-detects and dismisses cookie/consent dialogs on web pages.
+// Covers the top 10 consent frameworks plus generic text-matching fallback.
+//
+// All functions return JavaScript strings to inject via page.addInitScript()
+// or page.evaluate(). This module has no side effects — the caller decides
+// when and where to inject.
+//
+// Opt-in via LEAP_AUTO_CONSENT=true env var (caller checks, not this module).
+//
+// Per-domain cache: window.__leapfrog_consent_cache stores the winning
+// selector for each domain. On revisit the cached selector fires first
+// (instant dismissal, no 1.5s wait). Disk persistence is handled by
+// domain-knowledge.ts — this module is session-scoped only.
+//
+// ─── Selector Database ────────────────────────────────────────────────────
+export const CONSENT_SELECTORS = [
+    {
+        name: "OneTrust",
+        selectors: [
+            "#onetrust-accept-btn-handler",
+            ".onetrust-close-btn-handler",
+        ],
+    },
+    {
+        name: "CookieBot",
+        selectors: [
+            "#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll",
+            'a[id*="CybotCookiebot"][id*="Allow"]',
+        ],
+    },
+    {
+        name: "TrustArc",
+        selectors: [
+            ".truste-consent-required",
+            "a.call",
+            ".pdynamicbutton",
+        ],
+    },
+    {
+        name: "Quantcast",
+        selectors: [
+            '.qc-cmp2-summary-buttons button[mode="primary"]',
+            ".qc-cmp-button",
+        ],
+    },
+    {
+        name: "Didomi",
+        selectors: [
+            "#didomi-notice-agree-button",
+            ".didomi-continue-without-agreeing",
+        ],
+    },
+    {
+        name: "Cookielaw",
+        selectors: [
+            ".cc-compliance .cc-btn",
+            ".cc-dismiss",
+        ],
+    },
+    {
+        name: "Osano",
+        selectors: [
+            ".osano-cm-accept-all",
+        ],
+    },
+    {
+        name: "Usercentrics",
+        selectors: [
+            'button[data-testid="uc-accept-all-button"]',
+        ],
+    },
+    {
+        name: "Generic banner",
+        selectors: [
+            '[class*="cookie"] button',
+            '[class*="consent"] button',
+            '[id*="cookie"] button',
+        ],
+    },
+];
+// ─── Terms/TOS Checkbox Selectors ────────────────────────────────────────
+//
+// Auto-check terms/privacy checkboxes during form interaction. These fire
+// only when a form is being filled, not on page load (to avoid false positives).
+// Successful selectors are recorded in domain knowledge for instant replay.
+export const TERMS_SELECTORS = [
+    'input[type="checkbox"][name*="terms"]',
+    'input[type="checkbox"][name*="agree"]',
+    'input[type="checkbox"][name*="accept"]',
+    'input[type="checkbox"][name*="tos"]',
+    'input[type="checkbox"][name*="privacy"]',
+    'input[type="checkbox"][id*="terms"]',
+    'input[type="checkbox"][id*="agree"]',
+    'input[type="checkbox"][id*="accept"]',
+    'input[type="checkbox"][id*="tos"]',
+    'input[type="checkbox"][id*="policy"]',
+];
+/**
+ * Returns JS to inject via page.evaluate() that auto-checks unchecked
+ * terms/privacy/TOS checkboxes. Only targets form checkboxes whose labels
+ * or names indicate legal agreements. Returns which selectors matched.
+ */
+export function getTermsAutoCheckScript() {
+    return `(function() {
+  var SELECTORS = ${JSON.stringify(TERMS_SELECTORS)};
+  var checked = [];
+  for (var i = 0; i < SELECTORS.length; i++) {
+    var els = document.querySelectorAll(SELECTORS[i]);
+    for (var j = 0; j < els.length; j++) {
+      if (!els[j].checked) {
+        els[j].checked = true;
+        els[j].dispatchEvent(new Event('change', { bubbles: true }));
+        checked.push(SELECTORS[i]);
+      }
+    }
+  }
+  return { checked: checked.length, selectors: checked };
+})()`;
+}
+// ─── Text-Match Pattern ───────────────────────────────────────────────────
+const TEXT_MATCH_REGEX = "/^\\s*(accept\\s*(all|cookies)?|i\\s*agree|agree|got\\s*it|ok)\\s*$/i";
+// ─── Script Builders ──────────────────────────────────────────────────────
+/**
+ * Returns JS to inject via page.addInitScript().
+ * After page load + 1.5s delay, attempts to dismiss consent dialogs.
+ * Sets up a MutationObserver for lazily-loaded banners (auto-disconnects at 10s).
+ */
+export function getConsentDismissScript() {
+    return `(function() {
+  if (window.__leapfrog_consent_initialized) return;
+  window.__leapfrog_consent_initialized = true;
+
+  // ── Selector database ───────────────────────────────────────────────
+  var FRAMEWORKS = ${JSON.stringify(CONSENT_SELECTORS)};
+  var TEXT_RE = ${TEXT_MATCH_REGEX};
+
+  // ── Cache ───────────────────────────────────────────────────────────
+  if (!window.__leapfrog_consent_cache) {
+    window.__leapfrog_consent_cache = {};
+  }
+
+  // ── Helpers ─────────────────────────────────────────────────────────
+
+  function isVisible(el) {
+    if (!el) return false;
+    if (el.getAttribute && el.getAttribute('data-leapfrog') === 'true') return false;
+    var rect = el.getBoundingClientRect();
+    if (rect.height === 0 || rect.width === 0) return false;
+    if (el.offsetParent === null && getComputedStyle(el).position !== 'fixed') return false;
+    var inViewport = rect.top < window.innerHeight && rect.bottom > 0
+                  && rect.left < window.innerWidth && rect.right > 0;
+    return inViewport;
+  }
+
+  function isOnPolicyPage() {
+    var url = window.location.href.toLowerCase();
+    return url.indexOf('cookie-policy') !== -1 || url.indexOf('privacy') !== -1;
+  }
+
+  function tryClick(el) {
+    if (!el || !isVisible(el)) return false;
+    el.click();
+    return true;
+  }
+
+  // ── Core dismiss function ───────────────────────────────────────────
+
+  window.__leapfrog_dismissConsent = function() {
+    if (window.__leapfrog_consent_dismissed) {
+      return { dismissed: false, selector: '', framework: 'already-dismissed' };
+    }
+    if (isOnPolicyPage()) {
+      return { dismissed: false, selector: '', framework: 'policy-page-skip' };
+    }
+
+    var domain = window.location.hostname;
+
+    // 1. Try cached selector first
+    var cached = window.__leapfrog_consent_cache[domain];
+    if (cached) {
+      var cachedEl = document.querySelector(cached);
+      if (tryClick(cachedEl)) {
+        window.__leapfrog_consent_dismissed = true;
+        return { dismissed: true, selector: cached, framework: 'cached' };
+      }
+    }
+
+    // 2. Try framework-specific selectors
+    for (var i = 0; i < FRAMEWORKS.length; i++) {
+      var fw = FRAMEWORKS[i];
+      for (var j = 0; j < fw.selectors.length; j++) {
+        var sel = fw.selectors[j];
+        try {
+          var el = document.querySelector(sel);
+          if (tryClick(el)) {
+            window.__leapfrog_consent_cache[domain] = sel;
+            window.__leapfrog_consent_dismissed = true;
+            return { dismissed: true, selector: sel, framework: fw.name };
+          }
+        } catch (_) { /* invalid selector in this context, skip */ }
+      }
+    }
+
+    // 3. Fall back to text matching on visible buttons/links
+    //    Check both global candidates and elements inside modal dialogs
+    //    (CNN and similar sites use styled-component modals with <a> links)
+    var candidateSelectors = [
+      'button', 'a[role="button"]', '[role="button"]', 'a',
+      '[role="dialog"] button', '[role="dialog"] a',
+      '.modal button', '.modal a',
+      '[class*="modal"] button', '[class*="modal"] a'
+    ];
+    var candidates = document.querySelectorAll(candidateSelectors.join(', '));
+    for (var k = 0; k < candidates.length; k++) {
+      var c = candidates[k];
+      if (c.getAttribute && c.getAttribute('data-leapfrog') === 'true') continue;
+      var text = (c.textContent || '').trim();
+      if (TEXT_RE.test(text) && isVisible(c)) {
+        var matchSel = 'text:' + text;
+        window.__leapfrog_consent_cache[domain] = matchSel;
+        c.click();
+        window.__leapfrog_consent_dismissed = true;
+        return { dismissed: true, selector: matchSel, framework: 'GDPR Generic' };
+      }
+    }
+
+    return { dismissed: false, selector: '', framework: 'none' };
+  };
+
+  // ── Auto-run after DOMContentLoaded + 1.5s ─────────────────────────
+
+  function scheduleRun() {
+    setTimeout(function() {
+      window.__leapfrog_dismissConsent();
+    }, 1500);
+  }
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', scheduleRun);
+  } else {
+    scheduleRun();
+  }
+
+  // ── MutationObserver for lazily-loaded banners ──────────────────────
+
+  var observer = new MutationObserver(function(mutations) {
+    if (window.__leapfrog_consent_dismissed) {
+      observer.disconnect();
+      return;
+    }
+    // Only re-check if nodes were actually added
+    for (var m = 0; m < mutations.length; m++) {
+      if (mutations[m].addedNodes.length > 0) {
+        window.__leapfrog_dismissConsent();
+        break;
+      }
+    }
+  });
+
+  function startObserver() {
+    observer.observe(document.body || document.documentElement, {
+      childList: true,
+      subtree: true,
+    });
+    // Auto-disconnect after 10s to prevent memory leaks
+    setTimeout(function() { observer.disconnect(); }, 10000);
+  }
+
+  if (document.body) {
+    startObserver();
+  } else {
+    document.addEventListener('DOMContentLoaded', startObserver);
+  }
+
+})();`;
+}
+/**
+ * Returns JS that checks if a consent dialog is currently visible.
+ * Evaluates to `{ detected: boolean, frameworks: string[] }`.
+ */
+export function getConsentDetectScript() {
+    return `(function() {
+  var FRAMEWORKS = ${JSON.stringify(CONSENT_SELECTORS)};
+  var TEXT_RE = ${TEXT_MATCH_REGEX};
+  var detected = [];
+
+  function isVisible(el) {
+    if (!el) return false;
+    if (el.getAttribute && el.getAttribute('data-leapfrog') === 'true') return false;
+    var rect = el.getBoundingClientRect();
+    if (rect.height === 0 || rect.width === 0) return false;
+    if (el.offsetParent === null && getComputedStyle(el).position !== 'fixed') return false;
+    return rect.top < window.innerHeight && rect.bottom > 0
+        && rect.left < window.innerWidth && rect.right > 0;
+  }
+
+  for (var i = 0; i < FRAMEWORKS.length; i++) {
+    var fw = FRAMEWORKS[i];
+    for (var j = 0; j < fw.selectors.length; j++) {
+      try {
+        var el = document.querySelector(fw.selectors[j]);
+        if (isVisible(el)) {
+          detected.push(fw.name);
+          break;
+        }
+      } catch (_) {}
+    }
+  }
+
+  // Text fallback check — includes <a> tags and modal-scoped elements
+  var candidateSelectors = [
+    'button', 'a[role="button"]', '[role="button"]', 'a',
+    '[role="dialog"] button', '[role="dialog"] a',
+    '.modal button', '.modal a',
+    '[class*="modal"] button', '[class*="modal"] a'
+  ];
+  var candidates = document.querySelectorAll(candidateSelectors.join(', '));
+  for (var k = 0; k < candidates.length; k++) {
+    var text = (candidates[k].textContent || '').trim();
+    if (TEXT_RE.test(text) && isVisible(candidates[k])) {
+      detected.push('GDPR Generic');
+      break;
+    }
+  }
+
+  return { detected: detected.length > 0, frameworks: detected };
+})()`;
+}
+/**
+ * Returns JS to manually trigger consent dismissal (for retry scenarios).
+ * Resets the dismissed flag so the function runs fresh.
+ */
+export function getManualDismissScript() {
+    return `(function() {
+  window.__leapfrog_consent_dismissed = false;
+  if (typeof window.__leapfrog_dismissConsent === 'function') {
+    return window.__leapfrog_dismissConsent();
+  }
+  return { dismissed: false, selector: '', framework: 'not-initialized' };
+})()`;
+}
+/**
+ * Returns JS to cache a successful selector for a domain.
+ * Used when the caller already knows what worked (e.g. from disk persistence).
+ */
+export function getCacheSelectorScript(domain, selector) {
+    const safeDomain = domain.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    const safeSelector = selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    return `(function() {
+  if (!window.__leapfrog_consent_cache) {
+    window.__leapfrog_consent_cache = {};
+  }
+  window.__leapfrog_consent_cache['${safeDomain}'] = '${safeSelector}';
+  return true;
+})()`;
+}

package/dist/crash-recovery.d.ts

@@ -0,0 +1,74 @@
+import type { Browser, Page } from "playwright-core";
+import type { Session } from "./types.js";
+export interface HealthCheckResult {
+    healthy: boolean;
+    reason?: string;
+}
+export interface CrashLogEntry {
+    sessionId: string;
+    url: string;
+    timestamp: number;
+    error: string;
+}
+export declare class CrashRecovery {
+    /** Crash telemetry — all page crashes during server lifetime */
+    private crashLog;
+    /** Sessions marked as unhealthy after a page crash (pending recovery) */
+    private unhealthySessions;
+    /**
+     * Attach a disconnect handler to a Playwright Browser instance.
+     * On unexpected disconnect (crash, kill, OOM), logs the event and
+     * calls onCrash so the SessionManager can clear its state.
+     */
+    attachToBrowser(browser: Browser, onCrash: () => void): void;
+    /**
+     * Attach a page.on('crash') handler to catch Akamai-style browser context
+     * crashes. On crash: close the dead page, clean up the pool slot, log the
+     * event with the URL that caused the crash, and mark the session unhealthy.
+     *
+     * @param page The Playwright page to monitor
+     * @param session The session owning this page
+     * @param onCrash Optional callback when crash is detected (e.g., for cleanup)
+     */
+    attachToPage(page: Page, session: Session, onCrash?: (sessionId: string) => void): void;
+    /**
+     * Check if a session is marked as unhealthy (crashed but not yet recovered).
+     */
+    isUnhealthy(sessionId: string): boolean;
+    /**
+     * Mark a session as recovered after auto-recovery creates a replacement page.
+     */
+    markRecovered(sessionId: string): void;
+    /**
+     * Auto-recover a crashed session by creating a replacement page in the same
+     * browser context and re-applying stealth init scripts.
+     *
+     * @param session The session to recover
+     * @param applyStealthFn Callback to re-apply stealth to the new page
+     * @param rewireNetworkFn Callback to re-wire network intelligence
+     * @returns The new replacement page, or null if recovery failed
+     */
+    autoRecover(session: Session, applyStealthFn?: (page: Page) => Promise<void>, rewireNetworkFn?: (page: Page, session: Session) => void): Promise<Page | null>;
+    /**
+     * Quick health check for a single session.
+     * Verifies the page is not closed and can still evaluate JavaScript.
+     * Never throws — always returns a result object.
+     */
+    healthCheck(session: Session): Promise<HealthCheckResult>;
+    /**
+     * Run health checks on all sessions in parallel.
+     * Returns a Map from session ID to health result.
+     */
+    healthCheckAll(sessions: Map<string, Session>): Promise<Map<string, HealthCheckResult>>;
+    /**
+     * Get the crash log — all page crashes during the current server lifetime.
+     * Returns an array of {sessionId, url, timestamp, error} entries.
+     */
+    getCrashLog(): CrashLogEntry[];
+    /**
+     * Clear crash log (for testing or after log export).
+     */
+    clearCrashLog(): void;
+}
+export declare const crashRecovery: CrashRecovery;
+export default crashRecovery;