e2e-pilot 0.0.69

package/src/trace-utils.ts

@@ -0,0 +1,43 @@
+import { BrowserContext } from 'playwright-core'
+import fs from 'node:fs'
+import path from 'node:path'
+import { formatDateTimeForPath } from './utils.js'
+
+export interface ActiveTracing {
+  path: string
+  name: string
+}
+
+export async function startTracing({
+  context,
+  baseDir,
+}: {
+  context: BrowserContext
+  baseDir: string
+}): Promise<ActiveTracing> {
+  const now = new Date()
+  const dateTimeStr = formatDateTimeForPath(now)
+  const name = `trace-${dateTimeStr}`
+
+  fs.mkdirSync(baseDir, { recursive: true })
+  const tracePath = path.join(baseDir, `${dateTimeStr}.zip`)
+
+  await context.tracing.start({
+    name,
+    screenshots: true,
+    snapshots: true,
+  })
+
+  return { path: tracePath, name }
+}
+
+export async function stopTracing({
+  context,
+  activeTracing,
+}: {
+  context: BrowserContext
+  activeTracing: ActiveTracing
+}): Promise<string> {
+  await context.tracing.stop({ path: activeTracing.path })
+  return activeTracing.path
+}

package/src/utils.ts

@@ -0,0 +1,91 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { BrowserContext } from 'playwright-core'
+
+export const RELAY_PORT = Number(process.env.E2E_PILOT_PORT) || 19988
+
+export function getCdpUrl({
+  port = 19988,
+  host = '127.0.0.1',
+  token,
+}: { port?: number; host?: string; token?: string } = {}) {
+  const id = `${Math.random().toString(36).substring(2, 15)}_${Date.now()}`
+  const queryString = token ? `?token=${token}` : ''
+  return `ws://${host}:${port}/cdp/${id}${queryString}`
+}
+
+export const LOG_FILE_PATH =
+  process.env.E2E_PILOT_LOG_FILE_PATH || path.join(os.tmpdir(), 'e2e-pilot', 'relay-server.log')
+
+const packageJsonPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json')
+export const VERSION = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8')).version as string
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export async function getServerVersion(port: number = RELAY_PORT): Promise<string | null> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/version`, {
+      signal: AbortSignal.timeout(500),
+    })
+    if (!response.ok) {
+      return null
+    }
+    const data = (await response.json()) as { version: string }
+    return data.version
+  } catch {
+    return null
+  }
+}
+
+export function setDeviceScaleFactorForMacOS(context: BrowserContext): void {
+  if (os.platform() !== 'darwin') {
+    return
+  }
+  const options = (context as any)._options
+  if (!options || options.deviceScaleFactor === 2) {
+    return
+  }
+  options.deviceScaleFactor = 2
+}
+
+export function preserveSystemColorScheme(context: BrowserContext): void {
+  const options = (context as any)._options
+  if (!options) {
+    return
+  }
+  options.colorScheme = 'no-override'
+  options.reducedMotion = 'no-override'
+  options.forcedColors = 'no-override'
+}
+
+export function formatAsCommentLines(text: string): string {
+  return text
+    .split('\n')
+    .map((line) => {
+      return `// ${line}`
+    })
+    .join('\n')
+}
+
+function formatTimeForPath(date: Date): string {
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+  const seconds = String(date.getSeconds()).padStart(2, '0')
+  return `${hours}-${minutes}-${seconds}`
+}
+
+function formatDateForPath(date: Date): string {
+  return date.toISOString().split('T')[0]
+}
+
+/**
+ * Returns a combined date_time string for flattened folder structure.
+ * Format: YYYY-MM-DD_HH-MM-SS (e.g., 2026-01-13_12-53-00)
+ */
+export function formatDateTimeForPath(date: Date): string {
+  return `${formatDateForPath(date)}_${formatTimeForPath(date)}`
+}

package/src/wait-for-page-load.ts

@@ -0,0 +1,174 @@
+import type { Page } from 'playwright-core'
+import { sleep } from './utils.js'
+
+const FILTERED_DOMAINS = [
+  'doubleclick',
+  'googlesyndication',
+  'googleadservices',
+  'google-analytics',
+  'googletagmanager',
+  'facebook.net',
+  'fbcdn.net',
+  'twitter.com',
+  'linkedin.com',
+  'hotjar',
+  'mixpanel',
+  'segment.io',
+  'segment.com',
+  'newrelic',
+  'datadoghq',
+  'sentry.io',
+  'fullstory',
+  'amplitude',
+  'intercom',
+  'crisp.chat',
+  'zdassets.com',
+  'zendesk',
+  'tawk.to',
+  'hubspot',
+  'marketo',
+  'pardot',
+  'optimizely',
+  'crazyegg',
+  'mouseflow',
+  'clarity.ms',
+  'bing.com/bat',
+  'ads.',
+  'analytics.',
+  'tracking.',
+  'pixel.',
+]
+
+const FILTERED_EXTENSIONS = ['.gif', '.ico', '.cur', '.woff', '.woff2', '.ttf', '.otf', '.eot']
+
+export interface WaitForPageLoadOptions {
+  page: Page
+  timeout?: number
+  pollInterval?: number
+  minWait?: number
+}
+
+export interface WaitForPageLoadResult {
+  success: boolean
+  readyState: string
+  pendingRequests: string[]
+  waitTimeMs: number
+  timedOut: boolean
+}
+
+export async function waitForPageLoad(options: WaitForPageLoadOptions): Promise<WaitForPageLoadResult> {
+  const { page, timeout = 30000, pollInterval = 100, minWait = 500 } = options
+
+  const startTime = Date.now()
+  let timedOut = false
+  let lastReadyState = ''
+  let lastPendingRequests: string[] = []
+
+  const checkPageReady = async (): Promise<{ ready: boolean; readyState: string; pendingRequests: string[] }> => {
+    const result = await page.evaluate(
+      ({ filteredDomains, filteredExtensions, stuckThreshold, slowResourceThreshold }): {
+        ready: boolean
+        readyState: string
+        pendingRequests: string[]
+      } => {
+        const doc = globalThis.document as { readyState: string }
+        const readyState = doc.readyState
+
+        if (readyState !== 'complete') {
+          return { ready: false, readyState, pendingRequests: [`document.readyState: ${readyState}`] }
+        }
+
+        const resources = (performance as any).getEntriesByType('resource') as Array<{
+          name: string
+          startTime: number
+          responseEnd: number
+        }>
+        const now = (performance as any).now() as number
+
+        const pendingRequests = resources
+          .filter((r) => {
+            if (r.responseEnd > 0) {
+              return false
+            }
+
+            const elapsed = now - r.startTime
+            const url = r.name.toLowerCase()
+
+            if (url.startsWith('data:')) {
+              return false
+            }
+
+            if (filteredDomains.some((domain: string) => url.includes(domain))) {
+              return false
+            }
+
+            if (elapsed > stuckThreshold) {
+              return false
+            }
+
+            if (elapsed > slowResourceThreshold && filteredExtensions.some((ext: string) => url.includes(ext))) {
+              return false
+            }
+
+            return true
+          })
+          .map((r) => r.name)
+
+        return {
+          ready: pendingRequests.length === 0,
+          readyState,
+          pendingRequests,
+        }
+      },
+      {
+        filteredDomains: FILTERED_DOMAINS,
+        filteredExtensions: FILTERED_EXTENSIONS,
+        stuckThreshold: 10000,
+        slowResourceThreshold: 3000,
+      },
+    )
+
+    return result
+  }
+
+  await sleep(minWait)
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      const { ready, readyState, pendingRequests } = await checkPageReady()
+      lastReadyState = readyState
+      lastPendingRequests = pendingRequests
+
+      if (ready) {
+        return {
+          success: true,
+          readyState,
+          pendingRequests: [],
+          waitTimeMs: Date.now() - startTime,
+          timedOut: false,
+        }
+      }
+    } catch (e) {
+      console.error('[waitForPageLoad] page.evaluate failed:', e)
+      return {
+        success: false,
+        readyState: 'error',
+        pendingRequests: ['page.evaluate failed - page may have closed or navigated'],
+        waitTimeMs: Date.now() - startTime,
+        timedOut: false,
+      }
+    }
+
+    await sleep(pollInterval)
+  }
+
+  timedOut = true
+
+  return {
+    success: false,
+    readyState: lastReadyState,
+    pendingRequests: lastPendingRequests.slice(0, 10),
+    waitTimeMs: Date.now() - startTime,
+    timedOut,
+  }
+}