perfect-postcode/og-screenshot/src/screenshot.ts

import { chromium, type Browser, type Page } from 'playwright';
import { existsSync, readdirSync } from 'fs';

const VIEWPORT = { width: 1200, height: 630 };
const NAVIGATION_TIMEOUT = 15_000;
const TILE_BUFFER_MS = 500;
const POOL_SIZE = 3;

let browser: Browser | null = null;
const pagePool: Page[] = [];
let warmingUp = false;

/**
 * Detect if a GPU is available for hardware-accelerated rendering.
 * Checks for DRI devices on Linux which indicate GPU + driver availability.
 */
function detectGpu(): boolean {
  try {
    // Check for DRI render nodes (Linux)
    if (existsSync('/dev/dri')) {
      const devices = readdirSync('/dev/dri');
      // Look for renderD* (render nodes) or card* (display cards)
      const hasGpu = devices.some((d) => d.startsWith('renderD') || d.startsWith('card'));
      if (hasGpu) {
        console.log(`GPU detected: /dev/dri contains ${devices.join(', ')}`);
        return true;
      }
    }
  } catch {
    // Ignore errors - fall back to software rendering
  }
  console.log('No GPU detected, using SwiftShader software rendering');
  return false;
}

const hasGpu = detectGpu();

function getBrowserArgs(): string[] {
  const baseArgs = ['--no-sandbox', '--disable-dev-shm-usage'];

  if (hasGpu) {
    // Use hardware GPU acceleration
    return [...baseArgs, '--enable-gpu', '--enable-webgl'];
  } else {
    // Fall back to SwiftShader software rendering
    return [...baseArgs, '--use-gl=angle', '--use-angle=swiftshader'];
  }
}

async function ensureBrowser(): Promise<Browser> {
  if (!browser || !browser.isConnected()) {
    const args = getBrowserArgs();
    console.log(`Launching browser with args: ${args.join(' ')}`);
    browser = await chromium.launch({ args });
  }
  return browser;
}

async function createPage(): Promise<Page> {
  const instance = await ensureBrowser();
  const context = await instance.newContext({
    viewport: VIEWPORT,
    deviceScaleFactor: 1,
  });
  return context.newPage();
}

async function warmPool(): Promise<void> {
  if (warmingUp) return;
  warmingUp = true;

  try {
    const instance = await ensureBrowser();
    while (pagePool.length < POOL_SIZE && instance.isConnected()) {
      const page = await createPage();
      pagePool.push(page);
    }
  } finally {
    warmingUp = false;
  }
}

async function acquirePage(): Promise<Page> {
  // Try to get a page from the pool
  const page = pagePool.shift();
  if (page && !page.isClosed()) {
    // Refill pool in background
    warmPool().catch(() => {});
    return page;
  }

  // No pooled page available, create one
  const newPage = await createPage();
  // Start warming pool in background
  warmPool().catch(() => {});
  return newPage;
}

async function releasePage(page: Page): Promise<void> {
  try {
    if (page.isClosed()) return;

    // Reset page state for reuse
    await page.goto('about:blank', { timeout: 5000 }).catch(() => {});

    if (!page.isClosed() && pagePool.length < POOL_SIZE) {
      pagePool.push(page);
    } else {
      await page.context().close().catch(() => {});
    }
  } catch {
    await page.context().close().catch(() => {});
  }
}

export async function takeScreenshot(url: string): Promise<Buffer> {
  const page = await acquirePage();

  try {
    // Use domcontentloaded instead of networkidle - let __og_ready handle readiness
    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: NAVIGATION_TIMEOUT });

    // Wait for the frontend to signal readiness
    try {
      await page.waitForFunction('window.__og_ready === true', {
        timeout: NAVIGATION_TIMEOUT,
      });
    } catch {
      // Proceed anyway — partial screenshot is better than nothing
    }

    // Extra buffer for map tiles to finish rendering
    await page.waitForTimeout(TILE_BUFFER_MS);

    const screenshot = await page.screenshot({ type: 'png' });
    return Buffer.from(screenshot);
  } finally {
    await releasePage(page);
  }
}

export async function closeBrowser(): Promise<void> {
  // Close all pooled pages
  for (const page of pagePool) {
    await page.context().close().catch(() => {});
  }
  pagePool.length = 0;

  if (browser) {
    await browser.close().catch(() => {});
    browser = null;
  }
}

// Pre-warm the pool on module load
warmPool().catch(() => {});