playwriter 0.0.89 → 0.0.103

package/src/aria-snapshots/prosemirror-interactive.txt

@@ -0,0 +1,63 @@
+  - banner:
+    - navigation:
+      - role=link[name="ProseMirror"]
+        - role=link[name="Examples"]
+        - role=link[name="Documentation"]
+        - role=link[name="Discuss"] >> nth=0
+        - role=link[name="Code"]
+      - role=button[name="Toggle strong style"]
+      - role=button[name="Toggle emphasis"]
+      - role=button[name="Toggle code font"]
+      - role=button[name="Add or remove link"]
+      - role=button[name="Insert"]
+      - role=button[name="Type..."]
+      - role=button[name="Undo last change"]
+      - role=button[name="Redo last undone change"]
+      - role=button[name="Wrap in bullet list"]
+      - role=button[name="Wrap in ordered list"]
+      - role=button[name="Wrap in block quote"]
+      - role=button[name="⬚"]
+      - textbox [contenteditable="true"]:
+        - role=link[name="examples"] >> nth=0
+  - role=link[name="Markdown"]
+  - role=link[name="WYSIWYG"]
+  - list:
+    - listitem
+    - listitem
+    - listitem
+    - listitem
+    - listitem
+    - listitem
+  - role=link[name="open source"]
+  - role=link[name="Start here."]
+  - role=link[name="Forgejo"]
+  - role=link[name="welcome"]
+  - role=link[name="npm"]
+  - role=link[name="examples"] >> nth=1
+  - role=link[name="forum"]
+  - role=link[name="issue tracker"]
+  - role=link[name="code of conduct"]
+  - role=link[name="crowd-funded"]
+  - role=link[name="individuals and organizations"]
+  - role=link[name="Posit"]
+  - role=link[name="The New York Times"]
+  - role=link[name="Tiptap"]
+  - role=link[name="Progress"]
+  - role=link[name="Scripto"]
+  - role=link[name="Asana"]
+  - role=link[name="BlockNote"]
+  - role=link[name="Box"]
+  - role=link[name="Desmos"]
+  - role=link[name="Nextjournal"]
+  - role=link[name="Plickers"]
+  - role=link[name="The Guardian"]
+  - role=link[name="Yarn"]
+  - role=link[name="Fellow"]
+  - role=link[name="Sunsama"]
+  - contentinfo:
+    - navigation:
+      - role=link
+        - role=link[name="Backers"]
+        - role=link[name="Code of Conduct"]
+        - role=link[name="Discuss"] >> nth=1
+        - role=link[name="Report an Issue"]

package/src/aria-snapshots/prosemirror-raw.txt

@@ -0,0 +1,141 @@
+  - banner:
+    - navigation:
+      - role=link[name="ProseMirror"]
+        - role=link[name="Examples"]
+        - role=link[name="Documentation"]
+        - role=link[name="Discuss"] >> nth=0
+        - role=link[name="Code"]
+    - heading "A toolkit for building rich-text editors on the web"
+      - toolbar:
+        - role=button[name="Toggle strong style"]
+        - role=button[name="Toggle emphasis"]
+        - role=button[name="Toggle code font"]
+        - role=button[name="Add or remove link"]
+        - role=button[name="Insert"]
+        - role=button[name="Type..."]
+        - role=button[name="Undo last change"]
+        - role=button[name="Redo last undone change"]
+        - role=button[name="Wrap in bullet list"]
+        - role=button[name="Wrap in ordered list"]
+        - role=button[name="Wrap in block quote"]
+        - role=button[name="⬚"]
+      - textbox [contenteditable="true"]:
+        - paragraph:
+          - text: "Like this one!"
+        - paragraph:
+          - text: "Try it out by typing in here or see more"
+          - role=link[name="examples"] >> nth=0
+          - text: "."
+  - article:
+    - paragraph:
+      - text: "Rich content editors should, ideally, produce clean, semantically meaningful documents while still being easy for users to understand. ProseMirror tries to bridge the gap between editing explicit, unambiguous content like"
+      - role=link[name="Markdown"]
+      - text: "or XML, and classical"
+      - role=link[name="WYSIWYG"]
+      - text: "editors."
+    - paragraph:
+      - text: "It does this by implementing a WYSIWYG-style editing interface for documents more constrained and structured than plain HTML. You can customize the shape and structure of the documents your editor creates, and tailor them to your application's needs."
+    - heading "Features"
+    - list:
+      - listitem:
+        - heading "Collaborative editing"
+        - paragraph:
+          - text: "ProseMirror has built-in, ground-up, rock solid support for collaborative editing, where multiple people work on the same document in real time."
+      - listitem:
+        - heading "Extensible schemas"
+        - paragraph:
+          - text: "Document schemas allow editing documents with a custom structure without writing your own editor from scratch."
+      - listitem:
+        - heading "Modular"
+        - paragraph:
+          - text: "A modular architecture makes sure you only load the code you need, and can replace parts of the system as needed."
+      - listitem:
+        - heading "Pluggable"
+        - paragraph:
+          - text: "A plugin system allows you to easily enable additional functionality, and package your own extensions in a convenient format."
+      - listitem:
+        - heading "Functional"
+        - paragraph:
+          - text: "A largely functional and immutable architecture makes it easy to integrate ProseMirror into modern web apps, and confidently implement complex behavior."
+      - listitem:
+        - heading "Unopinionated"
+        - paragraph:
+          - text: "The core library is small and generic, providing a base onto which very different types of editors can be built."
+    - heading "About"
+    - paragraph:
+      - text: "ProseMirror is"
+      - role=link[name="open source"]
+      - text: ", and you are legally free to use it commercially. Yet, writing, maintaining, supporting, and setting up infrastructure for such a project takes a lot of work and energy. Therefore..."
+    - paragraph:
+      - text: "If you are using ProseMirror to make profit, there is a"
+      - text: "social"
+      - text: "expectation that you help fund its maintenance."
+      - role=link[name="Start here."]
+    - paragraph:
+      - text: "ProseMirror is being developed on"
+      - role=link[name="Forgejo"]
+      - text: ". Contributions are"
+      - role=link[name="welcome"]
+      - text: "."
+    - paragraph:
+      - text: "The easiest way to install ProseMirror is with"
+      - role=link[name="npm"]
+      - text: ". Take a look at the"
+      - role=link[name="examples"] >> nth=1
+      - text: "to get started."
+    - paragraph:
+      - text: "The library works on recent versions of Firefox, Chrome, Safari, and Edge, as well as on Internet Explorer 11."
+    - paragraph:
+      - text: "Discussing the project, or asking questions, is best done on the"
+      - role=link[name="forum"]
+      - text: ". Bugs should be reported through the"
+      - role=link[name="issue tracker"]
+      - text: ". We aim to be an inclusive, welcoming community. To make that explicit, we have a"
+      - role=link[name="code of conduct"]
+      - text: "that applies to communication around the project."
+    - heading "Sponsors"
+    - paragraph:
+      - text: "Initial development of the software was"
+      - role=link[name="crowd-funded"]
+      - text: "by these 414 excellent"
+      - role=link[name="individuals and organizations"]
+      - text: "."
+    - paragraph:
+      - text: "Ongoing development is supported by these companies:"
+    - role=link[name="Posit"]:
+      - image "Posit"
+    - role=link[name="The New York Times"]:
+      - image "The New York Times"
+    - role=link[name="Tiptap"]:
+      - image "Tiptap"
+    - role=link[name="Progress"]:
+      - image "Progress"
+    - role=link[name="Scripto"]:
+      - image "Scripto"
+    - role=link[name="Asana"]:
+      - image "Asana"
+    - role=link[name="BlockNote"]:
+      - image "BlockNote"
+    - role=link[name="Box"]:
+      - image "Box"
+    - role=link[name="Desmos"]:
+      - image "Desmos"
+    - role=link[name="Nextjournal"]:
+      - image "Nextjournal"
+    - role=link[name="Plickers"]:
+      - image "Plickers"
+    - role=link[name="The Guardian"]:
+      - image "The Guardian"
+    - role=link[name="Yarn"]:
+      - image "Yarn"
+    - role=link[name="Fellow"]:
+      - image "Fellow"
+    - role=link[name="Sunsama"]:
+      - image "Sunsama"
+  - contentinfo:
+    - navigation:
+      - role=link
+        - role=link[name="Backers"]
+        - role=link[name="Code of Conduct"]
+        - role=link[name="Discuss"] >> nth=1
+        - role=link[name="Report an Issue"]

package/src/browser-config.ts

@@ -1,64 +1,170 @@
 import fs from 'node:fs'
 import os from 'node:os'
+import path from 'node:path'
+import { chromium } from '@xmorse/playwright-core'
 
-// Function to get the browser executable path
-// Can be overridden by environment variable PLAYWRITER_BROWSER_PATH
-export function getBrowserExecutablePath(): string {
-  // Check environment variable first
-  const envPath = process.env.PLAYWRITER_BROWSER_PATH
-  if (envPath && fs.existsSync(envPath)) {
-    return envPath
+type BrowserLookupOptions = {
+  browserPath?: string
+  env?: NodeJS.ProcessEnv
+  platform?: NodeJS.Platform
+  homeDir?: string
+  existsSync?: (filePath: string) => boolean
+}
+
+function expandHomeDirectory({ filePath, homeDir }: { filePath: string; homeDir: string }): string {
+  if (!filePath.startsWith('~/')) {
+    return filePath
+  }
+  return path.join(homeDir, filePath.slice(2))
+}
+
+function dedupePaths(pathsToCheck: string[]): string[] {
+  return Array.from(new Set(pathsToCheck))
+}
+
+function getPlaywrightChromiumCandidate(): string[] {
+  const executablePath = chromium.executablePath()
+  if (!executablePath) {
+    return []
   }
+  return [executablePath]
+}
 
-  // Check for Ghost Browser on macOS
-  // const ghostBrowserPath = '/Applications/Ghost Browser.app/Contents/MacOS/Ghost Browser'
-  // if (fs.existsSync(ghostBrowserPath)) {
-  //     return ghostBrowserPath
-  // }
+function getPathEntries(env: NodeJS.ProcessEnv): string[] {
+  const rawPath = env.PATH || env.Path || ''
+  return rawPath
+    .split(path.delimiter)
+    .filter(Boolean)
+    .map((entry) => {
+      return entry.trim()
+    })
+}
+
+function getExecutableNames(platform: NodeJS.Platform): string[] {
+  if (platform === 'win32') {
+    return ['chrome.exe', 'chromium.exe']
+  }
+  return ['chrome', 'chromium', 'chromium-browser']
+}
 
-  // Fall back to finding Chrome
-  return findChromeExecutablePath()
+function getPathExecutableCandidates({
+  platform,
+  env,
+}: {
+  platform: NodeJS.Platform
+  env: NodeJS.ProcessEnv
+}): string[] {
+  const executableNames = getExecutableNames(platform)
+  return getPathEntries(env).flatMap((entry) => {
+    return executableNames.map((name) => {
+      return path.join(entry, name)
+    })
+  })
 }
 
-// Original Chrome finding logic
-function findChromeExecutablePath(): string {
-  const osPlatform = os.platform()
-  const paths = (() => {
-    if (osPlatform === 'darwin') {
+export function getBrowserExecutableCandidates({
+  platform = os.platform(),
+  env = process.env,
+  homeDir = os.homedir(),
+}: Omit<BrowserLookupOptions, 'browserPath' | 'existsSync'> = {}): string[] {
+  const platformCandidates = (() => {
+    if (platform === 'darwin') {
       return [
-        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-        '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+        '/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+        '~/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
         '/Applications/Chromium.app/Contents/MacOS/Chromium',
-        '~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        '~/Applications/Chromium.app/Contents/MacOS/Chromium',
       ]
     }
-    if (osPlatform === 'win32') {
+
+    if (platform === 'win32') {
+      const localAppData = env.LOCALAPPDATA || ''
+      const programFiles = env.PROGRAMFILES || 'C:\\Program Files'
+      const programFilesX86 = env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)'
+
       return [
-        'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
-        'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
-        `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`,
-        `${process.env.PROGRAMFILES}\\Google\\Chrome\\Application\\chrome.exe`,
-        `${process.env['PROGRAMFILES(X86)']}\\Google\\Chrome\\Application\\chrome.exe`,
-      ].filter(Boolean)
+        path.join(programFiles, 'Google', 'Chrome for Testing', 'Application', 'chrome.exe'),
+        path.join(programFilesX86, 'Google', 'Chrome for Testing', 'Application', 'chrome.exe'),
+        path.join(localAppData, 'Google', 'Chrome for Testing', 'Application', 'chrome.exe'),
+        path.join(programFiles, 'Chromium', 'Application', 'chromium.exe'),
+        path.join(programFilesX86, 'Chromium', 'Application', 'chromium.exe'),
+        path.join(localAppData, 'Chromium', 'Application', 'chromium.exe'),
+      ]
     }
-    // Linux
+
     return [
-      '/usr/bin/google-chrome',
-      '/usr/bin/google-chrome-stable',
+      '/opt/google/chrome-for-testing/chrome',
+      '/usr/local/bin/chrome',
+      '/usr/bin/chrome',
       '/usr/bin/chromium',
       '/usr/bin/chromium-browser',
       '/snap/bin/chromium',
     ]
   })()
 
-  for (const path of paths) {
-    const resolvedPath = path.startsWith('~') ? path.replace('~', os.homedir()) : path
-    if (fs.existsSync(resolvedPath)) {
-      return resolvedPath
+  const pathCandidates = getPathExecutableCandidates({ platform, env })
+  return dedupePaths(
+    [...platformCandidates, ...pathCandidates, ...getPlaywrightChromiumCandidate()].map((filePath) => {
+      return expandHomeDirectory({ filePath, homeDir })
+    }),
+  )
+}
+
+export function resolveBrowserExecutablePath({
+  browserPath,
+  env = process.env,
+  platform = os.platform(),
+  homeDir = os.homedir(),
+  existsSync = fs.existsSync,
+}: BrowserLookupOptions = {}): string {
+  const explicitPath = browserPath?.trim()
+  if (explicitPath) {
+    const resolvedExplicitPath = expandHomeDirectory({ filePath: explicitPath, homeDir })
+    if (!existsSync(resolvedExplicitPath)) {
+      throw new Error(`Browser binary not found at: ${resolvedExplicitPath}`)
+    }
+    return resolvedExplicitPath
+  }
+
+  const envPath = env.PLAYWRITER_BROWSER_PATH?.trim()
+  if (envPath) {
+    const resolvedEnvPath = expandHomeDirectory({ filePath: envPath, homeDir })
+    if (!existsSync(resolvedEnvPath)) {
+      throw new Error(`PLAYWRITER_BROWSER_PATH does not exist: ${resolvedEnvPath}`)
     }
+    return resolvedEnvPath
+  }
+
+  const candidates = getBrowserExecutableCandidates({ platform, env, homeDir })
+  const resolvedPath = candidates.find((candidate) => {
+    return existsSync(candidate)
+  })
+
+  if (resolvedPath) {
+    return resolvedPath
   }
 
+  const searchedPathsText = candidates.map((candidate) => {
+    return `- ${candidate}`
+  })
+
   throw new Error(
-    'Could not find Chrome executable. Please install Google Chrome or set PLAYWRITER_BROWSER_PATH environment variable.',
+    'Could not find a supported browser binary. Install Chrome for Testing or Chromium, or pass a binary path to `playwriter browser start`.' +
+      `\n\nSearched paths:\n${searchedPathsText.join('\n')}`,
   )
 }
+
+export function shouldUseHeadlessByDefault({
+  platform = os.platform(),
+  env = process.env,
+}: Omit<BrowserLookupOptions, 'browserPath' | 'homeDir' | 'existsSync'> = {}): boolean {
+  if (platform !== 'linux') {
+    return false
+  }
+
+  return !env.DISPLAY && !env.WAYLAND_DISPLAY
+}
+
+export function getBrowserExecutablePath(browserPath?: string): string {
+  return resolveBrowserExecutablePath({ browserPath })
+}

package/src/browser-launch.ts

@@ -0,0 +1,75 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { EXTENSION_IDS } from './utils.js'
+
+export type BrowserLaunchOptions = {
+  extensionPath: string
+  userDataDir: string
+  headless: boolean
+  noSandbox?: boolean
+  url?: string
+}
+
+export function getDefaultBrowserUserDataDir(): string {
+  return path.join(os.homedir(), '.playwriter', 'browser-profile')
+}
+
+export function getBrowserLaunchArgs({
+  extensionPath,
+  userDataDir,
+  headless,
+  noSandbox = false,
+  url = 'about:blank',
+}: BrowserLaunchOptions): string[] {
+  const recordingFlags = EXTENSION_IDS.map((extensionId) => {
+    return `--allowlisted-extension-id=${extensionId}`
+  })
+
+  const args = [
+    `--user-data-dir=${path.resolve(userDataDir)}`,
+    '--profile-directory=Default',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--auto-accept-this-tab-capture',
+    ...recordingFlags,
+    `--disable-extensions-except=${path.resolve(extensionPath)}`,
+    `--load-extension=${path.resolve(extensionPath)}`,
+  ]
+
+  if (headless) {
+    args.push('--headless=new')
+  }
+
+  if (noSandbox) {
+    args.push('--no-sandbox', '--disable-setuid-sandbox')
+  }
+
+  args.push(url)
+  return args
+}
+
+export function startBrowserProcess({
+  browserPath,
+  args,
+  userDataDir,
+}: {
+  browserPath: string
+  args: string[]
+  userDataDir: string
+}): { pid: number } {
+  fs.mkdirSync(path.resolve(userDataDir), { recursive: true })
+
+  const browserProcess = spawn(browserPath, args, {
+    detached: true,
+    stdio: 'ignore',
+  })
+  browserProcess.unref()
+
+  if (!browserProcess.pid) {
+    throw new Error(`Failed to start browser process for ${browserPath}`)
+  }
+
+  return { pid: browserProcess.pid }
+}

package/src/cdp-relay.ts

@@ -28,6 +28,7 @@ import { EventEmitter } from 'node:events'
 import { VERSION, EXTENSION_IDS } from './utils.js'
 import { createCdpLogger, type CdpLogEntry, type CdpLogger } from './cdp-log.js'
 import { RecordingRelay } from './recording-relay.js'
+import { appendSessionToWsUrl } from './chrome-discovery.js'
 import * as relayState from './relay-state.js'
 
 /**
@@ -1827,7 +1828,7 @@ export async function startPlayWriterCDPRelayServer({
       const existingExecutor = manager.getSession(sessionId)
       if (!existingExecutor) {
         return c.json(
-          { text: `Session ${sessionId} not found. Run 'playwriter session new' first.`, images: [], isError: true },
+          { text: `Session ${sessionId} not found. Run 'playwriter session new' first.`, images: [], screenshots: [], isError: true },
           404,
         )
       }
@@ -1836,7 +1837,7 @@ export async function startPlayWriterCDPRelayServer({
       return c.json(result)
     } catch (error: any) {
       logger?.error('Execute endpoint error:', error)
-      return c.json({ text: `Server error: ${error.message}`, images: [], isError: true }, 500)
+      return c.json({ text: `Server error: ${error.message}`, images: [], screenshots: [], isError: true }, 500)
     }
   })
 
@@ -1877,10 +1878,49 @@ export async function startPlayWriterCDPRelayServer({
   })
 
   app.post('/cli/session/new', async (c) => {
-    const body = (await c.req.json().catch(() => ({}))) as { extensionId?: string | null; cwd?: string }
+    const body = (await c.req.json().catch(() => ({}))) as {
+      extensionId?: string | null
+      cwd?: string
+      /** Direct CDP WebSocket URL — bypasses extension, connects straight to Chrome */
+      cdpEndpoint?: string
+      /** Browser name from discovery (e.g. "Chrome", "Brave") */
+      browser?: string
+      /** Profile info from discovery */
+      profiles?: Array<{ name: string; email: string }>
+    }
     const sessionId = String(nextSessionNumber++)
-    const extensionId = body.extensionId || null
     const cwd = body.cwd
+
+    // Direct CDP mode: skip extension lookup, pass direct WebSocket URL to executor
+    if (body.cdpEndpoint) {
+      if (!body.cdpEndpoint.startsWith('ws://') && !body.cdpEndpoint.startsWith('wss://')) {
+        return c.json({ error: `Invalid cdpEndpoint: must start with ws:// or wss:// (got: ${body.cdpEndpoint})` }, 400)
+      }
+      // Use first profile from discovery for session metadata (if available)
+      const firstProfile = body.profiles?.[0]
+      const manager = await getExecutorManager()
+      const executor = manager.getExecutor({
+        sessionId,
+        cwd,
+        cdpConfig: { directCdpUrl: appendSessionToWsUrl(body.cdpEndpoint, sessionId) },
+        sessionMetadata: {
+          extensionId: null,
+          browser: body.browser || null,
+          profile: firstProfile ? { email: firstProfile.email, id: firstProfile.name } : null,
+        },
+      })
+      const metadata = executor.getSessionMetadata()
+      return c.json({
+        id: sessionId,
+        mode: 'direct' as const,
+        extensionId: metadata.extensionId,
+        browser: metadata.browser,
+        profile: metadata.profile,
+      })
+    }
+
+    // Extension mode (existing behavior)
+    const extensionId = body.extensionId || null
     const allowDefault = !extensionId && store.getState().extensions.size === 1
     const conn = getExtensionConnection(extensionId, { allowFallback: allowDefault })
     if (!conn) {
@@ -1902,6 +1942,7 @@ export async function startPlayWriterCDPRelayServer({
     const metadata = executor.getSessionMetadata()
     return c.json({
       id: sessionId,
+      mode: 'extension' as const,
       extensionId: metadata.extensionId,
       browser: metadata.browser,
       profile: metadata.profile,
@@ -1915,13 +1956,7 @@ export async function startPlayWriterCDPRelayServer({
     if (!executor) {
       return c.json({ error: 'not found' }, 404)
     }
-    const metadata = executor.getSessionMetadata()
-    return c.json({
-      id: sessionId,
-      extensionId: metadata.extensionId,
-      browser: metadata.browser,
-      profile: metadata.profile,
-    })
+    return c.json(executor.getSessionInfo({ id: sessionId }))
   })
 
   app.post('/cli/session/delete', async (c) => {