@binary1702/site-packet 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# @binary1702/site-packet
+
+Turn any website into a printable review packet.
+
+## What it does
+
+1. Crawls all internal pages from a starting URL
+2. Captures full-page PNG screenshots
+3. Generates Letter-size PDFs with backgrounds
+4. Creates an index.html linking everything
+
+## Usage
+
+```bash
+npx @binary1702/site-packet https://example.com
+```
+
+### Options
+
+```bash
+# Custom output directory
+npx @binary1702/site-packet https://example.com -o ./my-review
+
+# Limit pages captured (default: 100)
+npx @binary1702/site-packet https://example.com --limit 20
+
+# Password-protected sites (Vercel previews, staging sites)
+npx @binary1702/site-packet https://staging.example.com -p 'your-password'
+```
+
+## Output
+
+```
+site-packet/
+├── index.html
+├── pdf/
+│   ├── 01-home.pdf
+│   ├── 02-about.pdf
+│   └── 03-contact.pdf
+└── screenshots/
+    ├── 01-home.png
+    ├── 02-about.png
+    └── 03-contact.png
+```
+
+Open `index.html` in a browser to view all captured pages with links to PDFs and screenshots.
+
+## Requirements
+
+- Node.js 18+
+- Chromium (downloaded automatically on first run)
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+import { createPacket } from '../src/index.js';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  console.log(`
+site-packet
+
+Turn a public website into a printable review packet.
+
+Usage:
+  site-packet <url> [options]
+
+Options:
+  --output, -o <dir>     Output directory (default: ./site-packet)
+  --limit, -l <n>        Maximum pages to capture (default: 100)
+  --password, -p <pass>  Site password (for password-protected sites)
+  --help, -h             Show this help message
+
+Examples:
+  site-packet https://example.com
+  site-packet https://example.com -o ./my-packet
+  site-packet https://example.com --limit 50
+  site-packet https://example.com -p mysecretpassword
+`);
+  process.exit(0);
+}
+
+// Parse arguments
+let url = null;
+let outputDir = './site-packet';
+let limit = 100;
+let password = null;
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+
+  if (arg === '--output' || arg === '-o') {
+    outputDir = args[++i];
+  } else if (arg === '--limit' || arg === '-l') {
+    limit = parseInt(args[++i], 10);
+    if (isNaN(limit) || limit < 1) {
+      console.error('Error: --limit must be a positive number');
+      process.exit(1);
+    }
+  } else if (arg === '--password' || arg === '-p') {
+    password = args[++i];
+  } else if (!arg.startsWith('-')) {
+    url = arg;
+  }
+}
+
+if (!url) {
+  console.error('Error: URL is required');
+  console.error('Usage: site-packet <url>');
+  process.exit(1);
+}
+
+// Validate URL
+try {
+  new URL(url);
+} catch {
+  console.error(`Error: Invalid URL "${url}"`);
+  process.exit(1);
+}
+
+// Run
+try {
+  await createPacket(url, { outputDir, limit, password });
+} catch (error) {
+  console.error(`\nFatal error: ${error.message}`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@binary1702/site-packet",
+  "version": "0.1.0",
+  "description": "Turn a public website into a printable website review packet",
+  "type": "module",
+  "bin": {
+    "site-packet": "./bin/cli.js"
+  },
+  "main": "./src/index.js",
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "website",
+    "screenshot",
+    "pdf",
+    "crawler",
+    "cli",
+    "review",
+    "packet"
+  ],
+  "author": "binary1702",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/binary1702/site-packet"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "playwright": "^1.40.0"
+  }
+}

package/src/crawler.js

@@ -0,0 +1,116 @@
+/**
+ * URL discovery and normalization
+ */
+
+/**
+ * Patterns to ignore in URLs
+ */
+const IGNORE_PATTERNS = [
+  /^mailto:/i,
+  /^tel:/i,
+  /^javascript:/i,
+  /^#/,
+  /\.(pdf|jpg|jpeg|png|gif|svg|ico|webp|mp4|mp3|wav|zip|tar|gz)$/i,
+  /\/api\//i,
+  /\/auth\//i,
+  /\/login/i,
+  /\/logout/i,
+  /\/signin/i,
+  /\/signout/i,
+  /\/signup/i,
+  /\/register/i,
+  /\/admin\//i,
+  /\/wp-admin/i,
+  /\/wp-login/i,
+];
+
+/**
+ * Normalize a URL for deduplication
+ * Removes query strings, hashes, trailing slashes
+ * Returns null if URL should be ignored
+ */
+export function normalizeUrl(href, baseUrl) {
+  // Check ignore patterns on raw href
+  for (const pattern of IGNORE_PATTERNS) {
+    if (pattern.test(href)) {
+      return null;
+    }
+  }
+
+  try {
+    const url = new URL(href, baseUrl);
+    const base = new URL(baseUrl);
+
+    // Must be same origin
+    if (url.origin !== base.origin) {
+      return null;
+    }
+
+    // Must be http(s)
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      return null;
+    }
+
+    // Remove hash
+    url.hash = '';
+
+    // Remove query string (duplicates)
+    url.search = '';
+
+    // Remove trailing slash (except for root)
+    let pathname = url.pathname;
+    if (pathname !== '/' && pathname.endsWith('/')) {
+      pathname = pathname.slice(0, -1);
+    }
+
+    return `${url.origin}${pathname}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract all links from a page using Playwright
+ * Returns array of normalized URLs
+ */
+export async function extractLinks(page, baseUrl) {
+  const hrefs = await page.evaluate(() => {
+    return Array.from(document.querySelectorAll('a[href]'))
+      .map(a => a.getAttribute('href'))
+      .filter(Boolean);
+  });
+
+  const normalized = new Set();
+
+  for (const href of hrefs) {
+    const url = normalizeUrl(href, baseUrl);
+    if (url) {
+      normalized.add(url);
+    }
+  }
+
+  return Array.from(normalized);
+}
+
+/**
+ * Convert URL to readable filename
+ * / -> home
+ * /about -> about
+ * /services/web-design -> services-web-design
+ */
+export function urlToFilename(url) {
+  const { pathname } = new URL(url);
+
+  if (pathname === '/') {
+    return 'home';
+  }
+
+  // Remove leading slash, replace remaining slashes with dashes
+  return pathname
+    .slice(1)
+    .replace(/\//g, '-')
+    .replace(/[^a-zA-Z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    .toLowerCase() || 'page';
+}

package/src/index.js

@@ -0,0 +1,193 @@
+/**
+ * Main orchestrator
+ * URL -> crawl -> render -> capture -> packet
+ */
+
+import { normalizeUrl, extractLinks, urlToFilename } from './crawler.js';
+import { createBrowser, createContext, capturePage, enterPassword } from './renderer.js';
+import { ensureOutputDirs, writeCapture, writeIndex } from './output.js';
+
+/**
+ * Create a website review packet
+ */
+export async function createPacket(seedUrl, options = {}) {
+  const { outputDir = './site-packet', limit = 100, password = null } = options;
+
+  console.log('\nsite-packet');
+  console.log(`Crawling ${seedUrl}...`);
+  console.log('');
+
+  // Normalize seed URL
+  const normalizedSeed = normalizeUrl(seedUrl, seedUrl);
+  if (!normalizedSeed) {
+    throw new Error('Invalid seed URL');
+  }
+
+  // Setup
+  await ensureOutputDirs(outputDir);
+  const browser = await createBrowser();
+
+  // Create a shared context (for cookie persistence across pages)
+  const context = await createContext(browser);
+
+  // State
+  const visitedPathnames = new Set(); // Dedupe by pathname (origin-agnostic after redirect resolution)
+  let authenticatedPage = null; // Keep auth page open to preserve session
+  let startUrl = normalizedSeed;
+  let authSessionData = null; // sessionStorage data from authentication
+
+  // Handle password-protected sites
+  if (password) {
+    console.log('Entering site password...');
+    authenticatedPage = await context.newPage();
+    try {
+      const { finalUrl, sessionData } = await enterPassword(authenticatedPage, normalizedSeed, password);
+      // Use the URL we landed on after auth (may be different)
+      startUrl = finalUrl;
+      authSessionData = sessionData;
+      console.log('Password accepted');
+      console.log('');
+    } catch (error) {
+      await context.close();
+      await browser.close();
+      throw new Error(`Password authentication failed: ${error.message}`);
+    }
+    // Don't close the auth page - we'll use it for the first capture
+  }
+
+  const queue = [startUrl];
+  const results = [];
+  let pageNumber = 0;
+  let successCount = 0;
+  let failCount = 0;
+  let effectiveOrigin = null; // Set after first page (handles redirects like example.com -> www.example.com)
+
+  try {
+    while (queue.length > 0 && pageNumber < limit) {
+      const url = queue.shift();
+      const pathname = new URL(url).pathname;
+
+      // Skip if already visited this pathname
+      if (visitedPathnames.has(pathname)) {
+        continue;
+      }
+      visitedPathnames.add(pathname);
+
+      pageNumber++;
+      const numStr = String(pageNumber).padStart(2, '0');
+
+      // For first page with password auth, reuse the authenticated page
+      // Otherwise create a fresh page
+      let page;
+      let needsNavigation = true;
+
+      if (authenticatedPage && pageNumber === 1) {
+        page = authenticatedPage;
+        authenticatedPage = null; // Only use once
+        needsNavigation = false; // Already on the page after auth
+      } else {
+        page = await context.newPage();
+      }
+
+      try {
+        // Capture the page
+        // First page: allow redirects to establish effective origin
+        // Subsequent pages: enforce effective origin
+        const captureOptions = effectiveOrigin ? { allowedOrigin: effectiveOrigin } : {};
+        if (!needsNavigation) {
+          captureOptions.skipNavigation = true;
+        }
+        if (authSessionData) {
+          captureOptions.sessionData = authSessionData;
+        }
+        const { title, screenshot, pdf, finalUrl } = await capturePage(page, url, captureOptions);
+
+        // After first page, lock to the resolved origin
+        if (!effectiveOrigin) {
+          effectiveOrigin = new URL(finalUrl).origin;
+          if (effectiveOrigin !== new URL(normalizedSeed).origin) {
+            console.log(`Following redirect to ${effectiveOrigin}`);
+            console.log('');
+          }
+        }
+
+        // Extract links for crawling (using effective origin for filtering)
+        const links = await extractLinks(page, effectiveOrigin);
+        for (const link of links) {
+          const linkPathname = new URL(link).pathname;
+          const inQueue = queue.some(q => new URL(q).pathname === linkPathname);
+          if (!visitedPathnames.has(linkPathname) && !inQueue) {
+            queue.push(link);
+          }
+        }
+
+        // Write files
+        const filename = `${numStr}-${urlToFilename(finalUrl)}`;
+        const { pdfPath, screenshotPath } = await writeCapture(
+          outputDir,
+          filename,
+          screenshot,
+          pdf
+        );
+
+        results.push({
+          number: pageNumber,
+          title,
+          url: finalUrl,
+          pdfPath,
+          screenshotPath,
+          error: null,
+        });
+
+        successCount++;
+        console.log(`✓ ${numStr} ${pathname}`);
+      } catch (error) {
+        results.push({
+          number: pageNumber,
+          title: null,
+          url,
+          pdfPath: null,
+          screenshotPath: null,
+          error: error.message,
+        });
+
+        failCount++;
+        console.log(`✗ ${numStr} ${pathname}`);
+      } finally {
+        await page.close();
+      }
+    }
+
+    // Generate index
+    await writeIndex(outputDir, results, {
+      seedUrl,
+      successCount,
+      failCount,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Summary
+    console.log('');
+    console.log(`${successCount} page${successCount !== 1 ? 's' : ''} captured`);
+    if (failCount > 0) {
+      console.log(`${failCount} page${failCount !== 1 ? 's' : ''} failed`);
+    }
+    if (pageNumber >= limit && queue.length > 0) {
+      console.log(`Stopped at limit (${limit}), ${queue.length} pages remaining`);
+    }
+    console.log('');
+    console.log(`Packet created:`);
+    console.log(`${outputDir}/`);
+    console.log('');
+  } finally {
+    await context.close();
+    await browser.close();
+  }
+
+  return {
+    outputDir,
+    successCount,
+    failCount,
+    totalPages: pageNumber,
+  };
+}

package/src/output.js

@@ -0,0 +1,192 @@
+/**
+ * File writing and index.html generation
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Ensure output directories exist
+ */
+export async function ensureOutputDirs(outputDir) {
+  await mkdir(join(outputDir, 'pdf'), { recursive: true });
+  await mkdir(join(outputDir, 'screenshots'), { recursive: true });
+}
+
+/**
+ * Write screenshot and PDF files
+ * Returns { pdfPath, screenshotPath }
+ */
+export async function writeCapture(outputDir, filename, screenshot, pdf) {
+  const pdfPath = join(outputDir, 'pdf', `${filename}.pdf`);
+  const screenshotPath = join(outputDir, 'screenshots', `${filename}.png`);
+
+  await Promise.all([
+    writeFile(pdfPath, pdf),
+    writeFile(screenshotPath, screenshot),
+  ]);
+
+  return {
+    pdfPath: `pdf/${filename}.pdf`,
+    screenshotPath: `screenshots/${filename}.png`,
+  };
+}
+
+/**
+ * Generate index.html
+ * @param {Array} pages - Array of { number, title, url, pdfPath, screenshotPath, error }
+ */
+export async function writeIndex(outputDir, pages, metadata) {
+  const { seedUrl, successCount, failCount, timestamp } = metadata;
+
+  const successPages = pages.filter(p => !p.error);
+  const failedPages = pages.filter(p => p.error);
+
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Site Packet: ${escapeHtml(new URL(seedUrl).hostname)}</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      line-height: 1.5;
+      padding: 2rem;
+      max-width: 1200px;
+      margin: 0 auto;
+      background: #f9fafb;
+    }
+    header {
+      margin-bottom: 2rem;
+      padding-bottom: 1rem;
+      border-bottom: 2px solid #e5e7eb;
+    }
+    h1 { font-size: 1.5rem; color: #111827; }
+    .meta { color: #6b7280; font-size: 0.875rem; margin-top: 0.5rem; }
+    .stats {
+      display: flex;
+      gap: 1rem;
+      margin-top: 0.5rem;
+    }
+    .stat {
+      padding: 0.25rem 0.75rem;
+      border-radius: 9999px;
+      font-size: 0.875rem;
+      font-weight: 500;
+    }
+    .stat-success { background: #d1fae5; color: #065f46; }
+    .stat-fail { background: #fee2e2; color: #991b1b; }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      background: white;
+      border-radius: 0.5rem;
+      overflow: hidden;
+      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    th, td {
+      padding: 0.75rem 1rem;
+      text-align: left;
+      border-bottom: 1px solid #e5e7eb;
+    }
+    th { background: #f3f4f6; font-weight: 600; color: #374151; }
+    tr:last-child td { border-bottom: none; }
+    tr:hover { background: #f9fafb; }
+    .num { width: 3rem; text-align: center; color: #6b7280; }
+    .title { font-weight: 500; }
+    .url { color: #6b7280; font-size: 0.875rem; word-break: break-all; }
+    .links { white-space: nowrap; }
+    .links a {
+      display: inline-block;
+      padding: 0.25rem 0.75rem;
+      margin-right: 0.5rem;
+      border-radius: 0.25rem;
+      text-decoration: none;
+      font-size: 0.875rem;
+      font-weight: 500;
+    }
+    .link-pdf { background: #dbeafe; color: #1e40af; }
+    .link-screenshot { background: #e0e7ff; color: #3730a3; }
+    .link-pdf:hover { background: #bfdbfe; }
+    .link-screenshot:hover { background: #c7d2fe; }
+    .error { color: #dc2626; font-style: italic; }
+    .failed-section { margin-top: 2rem; }
+    .failed-section h2 { font-size: 1rem; color: #991b1b; margin-bottom: 0.5rem; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Site Packet</h1>
+    <div class="meta">
+      <a href="${escapeHtml(seedUrl)}" target="_blank">${escapeHtml(seedUrl)}</a>
+    </div>
+    <div class="meta">Generated: ${escapeHtml(timestamp)}</div>
+    <div class="stats">
+      <span class="stat stat-success">${successCount} captured</span>
+      ${failCount > 0 ? `<span class="stat stat-fail">${failCount} failed</span>` : ''}
+    </div>
+  </header>
+
+  <table>
+    <thead>
+      <tr>
+        <th class="num">#</th>
+        <th>Page</th>
+        <th>URL</th>
+        <th>Files</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${successPages.map(p => `
+      <tr>
+        <td class="num">${String(p.number).padStart(2, '0')}</td>
+        <td class="title">${escapeHtml(p.title)}</td>
+        <td class="url">${escapeHtml(new URL(p.url).pathname)}</td>
+        <td class="links">
+          <a href="${escapeHtml(p.pdfPath)}" class="link-pdf">PDF</a>
+          <a href="${escapeHtml(p.screenshotPath)}" class="link-screenshot">PNG</a>
+        </td>
+      </tr>
+      `).join('')}
+    </tbody>
+  </table>
+
+  ${failedPages.length > 0 ? `
+  <div class="failed-section">
+    <h2>Failed Pages</h2>
+    <table>
+      <thead>
+        <tr>
+          <th class="num">#</th>
+          <th>URL</th>
+          <th>Error</th>
+        </tr>
+      </thead>
+      <tbody>
+        ${failedPages.map(p => `
+        <tr>
+          <td class="num">${String(p.number).padStart(2, '0')}</td>
+          <td class="url">${escapeHtml(new URL(p.url).pathname)}</td>
+          <td class="error">${escapeHtml(p.error)}</td>
+        </tr>
+        `).join('')}
+      </tbody>
+    </table>
+  </div>
+  ` : ''}
+</body>
+</html>`;
+
+  await writeFile(join(outputDir, 'index.html'), html);
+}
+
+function escapeHtml(str) {
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;');
+}

package/src/renderer.js

@@ -0,0 +1,239 @@
+/**
+ * Playwright-based page rendering (screenshot + PDF)
+ */
+
+import { chromium } from 'playwright';
+
+/**
+ * Create and configure a browser instance
+ */
+export async function createBrowser() {
+  return chromium.launch({
+    headless: true,
+  });
+}
+
+/**
+ * Create a browser context with standard configuration
+ * Contexts share cookies between pages
+ */
+export async function createContext(browser) {
+  return browser.newContext({
+    viewport: { width: 1280, height: 800 },
+    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  });
+}
+
+/**
+ * Enter password on a password-protected site
+ * Looks for common password form patterns
+ */
+export async function enterPassword(page, url, password) {
+  // Navigate to the site
+  await page.goto(url, {
+    waitUntil: 'networkidle',
+    timeout: 30000,
+  });
+
+  // Common password input selectors
+  const passwordSelectors = [
+    'input[type="password"]',
+    'input[name="password"]',
+    'input[id*="password"]',
+    'input[placeholder*="password" i]',
+    'input[placeholder*="Password" i]',
+  ];
+
+  let passwordInput = null;
+  for (const selector of passwordSelectors) {
+    try {
+      const input = page.locator(selector).first();
+      if (await input.isVisible({ timeout: 500 })) {
+        passwordInput = input;
+        break;
+      }
+    } catch {
+      // Continue trying
+    }
+  }
+
+  if (!passwordInput) {
+    throw new Error('Could not find password input field');
+  }
+
+  // Fill password
+  await passwordInput.fill(password);
+
+  // Find and click submit button (case-insensitive text matching)
+  const submitSelectors = [
+    'button[type="submit"]',
+    'input[type="submit"]',
+    'button:has-text("ENTER SITE")',
+    'button:has-text("Enter Site")',
+    'button:has-text("enter site")',
+    'button:has-text("Enter")',
+    'button:has-text("Submit")',
+    'button:has-text("Login")',
+    'button:has-text("Sign in")',
+    // Look for button near the password input
+    'form button',
+  ];
+
+  let submitted = false;
+  for (const selector of submitSelectors) {
+    try {
+      const button = page.locator(selector).first();
+      if (await button.isVisible({ timeout: 500 })) {
+        // Click and wait for navigation simultaneously
+        await Promise.all([
+          page.waitForLoadState('networkidle', { timeout: 15000 }).catch(() => {}),
+          button.click(),
+        ]);
+        submitted = true;
+        break;
+      }
+    } catch {
+      // Continue trying
+    }
+  }
+
+  // If no button found, try pressing Enter
+  if (!submitted) {
+    await Promise.all([
+      page.waitForLoadState('networkidle', { timeout: 15000 }).catch(() => {}),
+      passwordInput.press('Enter'),
+    ]);
+  }
+
+  // Give extra time for cookie to be set and any client-side redirects
+  await page.waitForTimeout(2000);
+
+  // Capture sessionStorage (Vercel password protection uses this)
+  const sessionData = await page.evaluate(() => {
+    const data = {};
+    for (let i = 0; i < window.sessionStorage.length; i++) {
+      const key = window.sessionStorage.key(i);
+      data[key] = window.sessionStorage.getItem(key);
+    }
+    return data;
+  });
+
+  // Return the final URL and session data
+  return { finalUrl: page.url(), sessionData };
+}
+
+/**
+ * Navigate to a URL and capture screenshot + PDF
+ * Returns { title, screenshot, pdf, finalUrl } buffers or throws on failure
+ *
+ * @param {object} options
+ * @param {number} options.timeout - Navigation timeout in ms
+ * @param {string} options.allowedOrigin - If provided, only allow redirects within this origin
+ * @param {boolean} options.skipNavigation - If true, skip navigation (page already loaded)
+ * @param {object} options.sessionData - sessionStorage data to inject before navigation
+ */
+export async function capturePage(page, url, options = {}) {
+  const { timeout = 30000, allowedOrigin = null, skipNavigation = false, sessionData = null } = options;
+
+  if (!skipNavigation) {
+    // If we have sessionData, we need to inject it after navigating to the domain
+    // but before the page checks auth. We do this via page.addInitScript
+    if (sessionData && Object.keys(sessionData).length > 0) {
+      await page.addInitScript((data) => {
+        for (const [key, value] of Object.entries(data)) {
+          window.sessionStorage.setItem(key, value);
+        }
+      }, sessionData);
+    }
+
+    // Navigate with timeout
+    const response = await page.goto(url, {
+      waitUntil: 'networkidle',
+      timeout,
+    });
+
+    // Check response
+    if (!response) {
+      throw new Error('No response received');
+    }
+
+    const status = response.status();
+    if (status >= 400) {
+      throw new Error(`HTTP ${status}`);
+    }
+  }
+
+  // Get final URL after redirects (or current URL if skipped navigation)
+  const finalUrl = page.url();
+  const finalOrigin = new URL(finalUrl).origin;
+
+  // If allowedOrigin is set, verify we stayed within it
+  if (allowedOrigin && finalOrigin !== allowedOrigin) {
+    throw new Error(`Redirected outside allowed origin: ${finalOrigin}`);
+  }
+
+  // Get page title
+  const title = await page.title() || 'Untitled';
+
+  // Dismiss common modals/cookie banners (best effort)
+  await dismissModals(page);
+
+  // Small delay for final renders
+  await page.waitForTimeout(500);
+
+  // Full-page screenshot
+  const screenshot = await page.screenshot({
+    fullPage: true,
+    type: 'png',
+  });
+
+  // Letter-size PDF with backgrounds
+  const pdf = await page.pdf({
+    format: 'Letter',
+    printBackground: true,
+    margin: {
+      top: '0.5in',
+      right: '0.5in',
+      bottom: '0.5in',
+      left: '0.5in',
+    },
+  });
+
+  return { title, screenshot, pdf, finalUrl };
+}
+
+/**
+ * Best-effort modal/cookie banner dismissal
+ */
+async function dismissModals(page) {
+  const selectors = [
+    // Cookie consent buttons
+    'button[id*="accept"]',
+    'button[id*="cookie"]',
+    'button[class*="accept"]',
+    'button[class*="cookie"]',
+    '[aria-label*="accept"]',
+    '[aria-label*="Accept"]',
+    // Close buttons
+    'button[aria-label="Close"]',
+    'button[aria-label="close"]',
+    '.modal-close',
+    '.close-modal',
+    // Common cookie banner classes
+    '.cookie-banner button',
+    '.cookie-notice button',
+    '#cookie-banner button',
+  ];
+
+  for (const selector of selectors) {
+    try {
+      const button = page.locator(selector).first();
+      if (await button.isVisible({ timeout: 100 })) {
+        await button.click({ timeout: 500 });
+        await page.waitForTimeout(200);
+      }
+    } catch {
+      // Ignore failures
+    }
+  }
+}