playwriter 0.0.63 → 0.0.89

package/src/recording-ghost-cursor.ts

@@ -0,0 +1,113 @@
+/**
+ * Encapsulates ghost cursor lifecycle for recording sessions.
+ * Keeps onMouseAction chaining/restoration isolated from executor logic.
+ */
+
+import type { BrowserContext, Page } from '@xmorse/playwright-core'
+import {
+  applyGhostCursorMouseAction,
+  disableGhostCursor,
+  enableGhostCursor,
+  type GhostCursorClientOptions,
+} from './ghost-cursor.js'
+
+interface RecordingGhostCursorLogger {
+  error: (...args: unknown[]) => void
+}
+
+interface RecordingTargetOptions {
+  page?: Page
+  sessionId?: string
+}
+
+export class RecordingGhostCursorController {
+  private readonly previousMouseActionByPage = new WeakMap<Page, Page['onMouseAction']>()
+  private readonly cursorApplyQueueByPage = new WeakMap<Page, Promise<void>>()
+  private readonly logger: RecordingGhostCursorLogger
+
+  constructor(options: { logger: RecordingGhostCursorLogger }) {
+    this.logger = options.logger
+  }
+
+  resolveRecordingTargetPage(options: {
+    context: BrowserContext
+    defaultPage: Page
+    target?: RecordingTargetOptions
+  }): Page {
+    const { context, defaultPage, target } = options
+
+    if (target?.page) {
+      return target.page
+    }
+
+    if (target?.sessionId) {
+      const pageForSession = context.pages().find((candidatePage) => {
+        return candidatePage.sessionId() === target.sessionId
+      })
+
+      if (pageForSession) {
+        return pageForSession
+      }
+    }
+
+    return defaultPage
+  }
+
+  async enableForRecording(options: { page: Page }): Promise<void> {
+    const { page } = options
+
+    try {
+      await enableGhostCursor({ page })
+
+      if (!this.previousMouseActionByPage.has(page)) {
+        this.previousMouseActionByPage.set(page, page.onMouseAction)
+      }
+
+      const previousMouseAction = this.previousMouseActionByPage.get(page)
+      page.onMouseAction = async (event) => {
+        const pendingCursorApply = this.cursorApplyQueueByPage.get(page) || Promise.resolve()
+        const nextCursorApply = pendingCursorApply
+          .then(async () => {
+            await applyGhostCursorMouseAction({ page, event })
+          })
+          .catch((error) => {
+            this.logger.error('[playwriter] Failed to apply ghost cursor action', error)
+          })
+        this.cursorApplyQueueByPage.set(page, nextCursorApply)
+
+        if (!previousMouseAction) {
+          return
+        }
+
+        await previousMouseAction(event)
+      }
+    } catch (error) {
+      page.onMouseAction = this.previousMouseActionByPage.get(page) ?? null
+      this.previousMouseActionByPage.delete(page)
+      this.logger.error('[playwriter] Failed to enable ghost cursor', error)
+    }
+  }
+
+  async disableForRecording(options: { page: Page }): Promise<void> {
+    const { page } = options
+    page.onMouseAction = this.previousMouseActionByPage.get(page) ?? null
+    this.previousMouseActionByPage.delete(page)
+    this.cursorApplyQueueByPage.delete(page)
+
+    try {
+      await disableGhostCursor({ page })
+    } catch (error) {
+      this.logger.error('[playwriter] Failed to disable ghost cursor', error)
+    }
+  }
+
+  async show(options: { page: Page; cursorOptions?: GhostCursorClientOptions }): Promise<void> {
+    const { page, cursorOptions } = options
+    await enableGhostCursor({ page, cursorOptions })
+  }
+
+  async hide(options: { page: Page }): Promise<void> {
+    const { page } = options
+    await disableGhostCursor({ page })
+  }
+}

package/src/recording-relay.ts

@@ -22,7 +22,7 @@ import type {
 // Recording state - tracks active recordings and their accumulated chunks
 export interface ActiveRecording {
   tabId: number
-  sessionId?: string  // The sessionId used to start this recording, for lookup when stopping
+  sessionId?: string // The sessionId used to start this recording, for lookup when stopping
   outputPath: string
   chunks: Buffer[]
   startedAt: number
@@ -40,7 +40,7 @@ export class RecordingRelay {
   constructor(
     sendToExtension: (params: { method: string; params?: unknown; timeout?: number }) => Promise<unknown>,
     isExtensionConnected: () => boolean,
-    logger?: { log(...args: unknown[]): void; error(...args: unknown[]): void }
+    logger?: { log(...args: unknown[]): void; error(...args: unknown[]): void },
   ) {
     this.sendToExtension = sendToExtension
     this.isExtensionConnected = isExtensionConnected
@@ -58,7 +58,11 @@ export class RecordingRelay {
       const recording = this.activeRecordings.get(tabId)
       if (recording) {
         recording.chunks.push(buffer)
-        this.logger?.log(pc.blue(`Received recording chunk for tab ${tabId}: ${buffer.length} bytes (total chunks: ${recording.chunks.length})`))
+        this.logger?.log(
+          pc.blue(
+            `Received recording chunk for tab ${tabId}: ${buffer.length} bytes (total chunks: ${recording.chunks.length})`,
+          ),
+        )
       } else {
         this.logger?.log(pc.yellow(`Received recording chunk for unknown tab ${tabId}, ignoring`))
       }
@@ -140,11 +144,11 @@ export class RecordingRelay {
     }
 
     try {
-      const result = await this.sendToExtension({
+      const result = (await this.sendToExtension({
         method: 'startRecording',
         params: recordingParams,
         timeout: 10000,
-      }) as StartRecordingResult
+      })) as StartRecordingResult
 
       if (!result) {
         return { success: false, error: 'Extension returned empty result' }
@@ -158,7 +162,11 @@ export class RecordingRelay {
           chunks: [],
           startedAt: result.startedAt,
         })
-        this.logger?.log(pc.green(`Recording started for tab ${result.tabId} (sessionId: ${recordingParams.sessionId || 'none'}), output: ${outputPath}`))
+        this.logger?.log(
+          pc.green(
+            `Recording started for tab ${result.tabId} (sessionId: ${recordingParams.sessionId || 'none'}), output: ${outputPath}`,
+          ),
+        )
       }
 
       return result
@@ -211,11 +219,11 @@ export class RecordingRelay {
     })
 
     try {
-      const result = await this.sendToExtension({
+      const result = (await this.sendToExtension({
         method: 'stopRecording',
         params,
         timeout: 10000,
-      }) as StopRecordingResult
+      })) as StopRecordingResult
 
       if (!result.success) {
         recording.resolveStop = undefined
@@ -237,11 +245,11 @@ export class RecordingRelay {
     }
 
     try {
-      return await this.sendToExtension({
+      return (await this.sendToExtension({
         method: 'isRecording',
         params,
         timeout: 5000,
-      }) as IsRecordingResult
+      })) as IsRecordingResult
     } catch {
       return { isRecording: false }
     }
@@ -253,11 +261,11 @@ export class RecordingRelay {
     }
 
     try {
-      return await this.sendToExtension({
+      return (await this.sendToExtension({
         method: 'cancelRecording',
         params,
         timeout: 5000,
-      }) as CancelRecordingResult
+      })) as CancelRecordingResult
     } catch (error: unknown) {
       const errorMessage = error instanceof Error ? error.message : String(error)
       this.logger?.error('Cancel recording error:', error)

package/src/relay-client.ts

@@ -15,10 +15,19 @@ const __dirname = path.dirname(__filename)
 
 export const RELAY_PORT = Number(process.env.PLAYWRITER_PORT) || 19988
 
+export type ExtensionStatus = {
+  extensionId: string
+  stableKey?: string
+  browser: string | null
+  profile: { email: string; id: string } | null
+  activeTargets: number
+  playwriterVersion: string | null
+}
+
 export async function getRelayServerVersion(port: number = RELAY_PORT): Promise<string | null> {
   try {
     const response = await fetch(`http://127.0.0.1:${port}/version`, {
-      signal: AbortSignal.timeout(500),
+      signal: AbortSignal.timeout(2000),
     })
     if (!response.ok) {
       return null
@@ -30,7 +39,9 @@ export async function getRelayServerVersion(port: number = RELAY_PORT): Promise<
   }
 }
 
-export async function getExtensionStatus(port: number = RELAY_PORT): Promise<{ connected: boolean; activeTargets: number; playwriterVersion: string | null } | null> {
+export async function getExtensionStatus(
+  port: number = RELAY_PORT,
+): Promise<{ connected: boolean; activeTargets: number; playwriterVersion: string | null } | null> {
   try {
     const response = await fetch(`http://127.0.0.1:${port}/extension/status`, {
       signal: AbortSignal.timeout(500),
@@ -38,37 +49,87 @@ export async function getExtensionStatus(port: number = RELAY_PORT): Promise<{ c
     if (!response.ok) {
       return null
     }
-    return await response.json() as { connected: boolean; activeTargets: number; playwriterVersion: string | null }
+    return (await response.json()) as { connected: boolean; activeTargets: number; playwriterVersion: string | null }
   } catch {
     return null
   }
 }
 
+export async function getExtensionsStatus(port: number = RELAY_PORT): Promise<ExtensionStatus[]> {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/extensions/status`, {
+      signal: AbortSignal.timeout(2000),
+    })
+    if (!response.ok) {
+      const fallback = await fetch(`http://127.0.0.1:${port}/extension/status`, {
+        signal: AbortSignal.timeout(2000),
+      })
+      if (!fallback.ok) {
+        return []
+      }
+
+      const fallbackData = (await fallback.json()) as {
+        connected: boolean
+        activeTargets: number
+        browser: string | null
+        profile: { email: string; id: string } | null
+        playwriterVersion?: string | null
+      }
+
+      if (!fallbackData?.connected) {
+        return []
+      }
+
+      return [
+        {
+          extensionId: 'default',
+          stableKey: undefined,
+          browser: fallbackData.browser,
+          profile: fallbackData.profile,
+          activeTargets: fallbackData.activeTargets,
+          playwriterVersion: fallbackData.playwriterVersion || null,
+        },
+      ]
+    }
+
+    const data = (await response.json()) as {
+      extensions: ExtensionStatus[]
+    }
+
+    return data.extensions || []
+  } catch {
+    return []
+  }
+}
+
 /**
- * Wait for the extension to connect to the relay server.
- * Returns true if connected within timeout, false otherwise.
+ * Wait for at least one extension to appear in extensions status.
+ * Returns connected extension entries, or [] on timeout.
  */
-export async function waitForExtension(options: {
-  port?: number
-  timeoutMs?: number
-  logger?: { log: (...args: any[]) => void }
-} = {}): Promise<boolean> {
-  const { port = RELAY_PORT, timeoutMs = 5000, logger } = options
+export async function waitForConnectedExtensions(
+  options: {
+    port?: number
+    timeoutMs?: number
+    pollIntervalMs?: number
+    logger?: { log: (...args: any[]) => void }
+  } = {},
+): Promise<ExtensionStatus[]> {
+  const { port = RELAY_PORT, timeoutMs = 5000, pollIntervalMs = 200, logger } = options
   const startTime = Date.now()
 
   logger?.log(pc.dim('Waiting for extension to connect...'))
 
   while (Date.now() - startTime < timeoutMs) {
-    const status = await getExtensionStatus(port)
-    if (status?.connected) {
+    const extensions = await getExtensionsStatus(port)
+    if (extensions.length > 0) {
       logger?.log(pc.green('Extension connected'))
-      return true
+      return extensions
     }
-    await sleep(200)
+    await sleep(pollIntervalMs)
   }
 
   logger?.log(pc.yellow('Extension did not connect within timeout'))
-  return false
+  return []
 }
 
 async function killRelayServer(options: { port: number; waitForFreeMs?: number }): Promise<void> {
@@ -155,7 +216,9 @@ export async function ensureRelayServer(options: EnsureRelayServerOptions = {}):
 
   if (serverVersion !== null) {
     if (restartOnVersionMismatch) {
-      logger?.log(pc.yellow(`CDP relay server version mismatch (server: ${serverVersion}, client: ${VERSION}), restarting...`))
+      logger?.log(
+        pc.yellow(`CDP relay server version mismatch (server: ${serverVersion}, client: ${VERSION}), restarting...`),
+      )
       await killRelayServer({ port: RELAY_PORT })
     } else {
       // Server is running but different version, just use it
@@ -164,7 +227,11 @@ export async function ensureRelayServer(options: EnsureRelayServerOptions = {}):
   } else {
     const listeningPids = await getListeningPidsForPort({ port: RELAY_PORT }).catch(() => [])
     if (listeningPids.length > 0) {
-      logger?.log(pc.yellow(`Port ${RELAY_PORT} is already in use (pid(s): ${listeningPids.join(', ')}). Attempting to stop the existing process...`))
+      logger?.log(
+        pc.yellow(
+          `Port ${RELAY_PORT} is already in use (pid(s): ${listeningPids.join(', ')}). Attempting to stop the existing process...`,
+        ),
+      )
       await killRelayServer({ port: RELAY_PORT })
     }