tabwright 1.0.0

package/src/rrweb-recording.ts

@@ -0,0 +1,322 @@
+import path from 'node:path'
+import type { BrowserContext, Page } from '@xmorse/playwright-core'
+import { getLocalRelayHttpBaseUrl } from './relay-client.js'
+import type {
+  CancelRrwebRecordingResult,
+  IsRrwebRecordingResult,
+  RrwebEvent,
+  StartRrwebRecordingResult,
+  StopRrwebRecordingResult,
+} from './protocol.js'
+
+function replayHeaders(): Record<string, string> {
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+  const token = process.env.TABWRIGHT_TOKEN || process.env.PLAYWRITER_TOKEN
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`
+  }
+  return headers
+}
+
+async function getReplayRelayBaseUrl(relayPort: number): Promise<string> {
+  return await getLocalRelayHttpBaseUrl(relayPort)
+}
+
+export interface StartReplayOptions {
+  page: Page
+  sessionId?: string
+  outputPath?: string
+  relayPort?: number
+  checkoutEveryNms?: number
+  maskAllInputs?: boolean
+  recordCanvas?: boolean
+  inlineImages?: boolean
+  collectFonts?: boolean
+  mousemoveWait?: number
+}
+
+export interface StopReplayOptions {
+  page: Page
+  sessionId?: string
+  relayPort?: number
+}
+
+export interface ReplayState {
+  isRecording: boolean
+  startedAt?: number
+  tabId?: number
+  url?: string
+}
+
+export interface SavedReplayRecording {
+  id: string
+  path: string
+  startedAt: number
+  savedAt: number
+  duration: number
+  size: number
+  eventCount: number
+  tabId: number
+  sessionId?: string
+  url?: string
+}
+
+interface ListReplayRecordingsResponse {
+  recordings: SavedReplayRecording[]
+}
+
+interface ReplayRecordingEventsResponse {
+  recording: SavedReplayRecording
+  events: RrwebEvent[]
+}
+
+interface ReplayTargetOptions {
+  page?: Page
+  sessionId?: string
+}
+
+interface CreateReplayApiOptions {
+  context: BrowserContext
+  defaultPage: Page
+  relayPort: number
+}
+
+interface StartReplayWithDefaultsOptions extends Omit<StartReplayOptions, 'relayPort' | 'page' | 'sessionId'>, ReplayTargetOptions {}
+interface StopReplayWithDefaultsOptions extends Omit<StopReplayOptions, 'relayPort' | 'page' | 'sessionId'>, ReplayTargetOptions {}
+interface IsReplayWithDefaultsOptions extends ReplayTargetOptions {}
+interface CancelReplayWithDefaultsOptions extends ReplayTargetOptions {}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function isStringOrUndefined(value: unknown): value is string | undefined {
+  return value === undefined || typeof value === 'string'
+}
+
+function isRrwebEvent(value: unknown): value is RrwebEvent {
+  return isRecord(value)
+}
+
+function isSavedReplayRecording(value: unknown): value is SavedReplayRecording {
+  if (!isRecord(value)) return false
+  return (
+    typeof value.id === 'string' &&
+    typeof value.path === 'string' &&
+    typeof value.startedAt === 'number' &&
+    typeof value.savedAt === 'number' &&
+    typeof value.duration === 'number' &&
+    typeof value.size === 'number' &&
+    typeof value.eventCount === 'number' &&
+    typeof value.tabId === 'number' &&
+    isStringOrUndefined(value.sessionId) &&
+    isStringOrUndefined(value.url)
+  )
+}
+
+function isListReplayRecordingsResponse(value: unknown): value is ListReplayRecordingsResponse {
+  return (
+    isRecord(value) &&
+    Array.isArray(value.recordings) &&
+    value.recordings.every((recording) => {
+      return isSavedReplayRecording(recording)
+    })
+  )
+}
+
+function isReplayRecordingEventsResponse(value: unknown): value is ReplayRecordingEventsResponse {
+  return (
+    isRecord(value) &&
+    isSavedReplayRecording(value.recording) &&
+    Array.isArray(value.events) &&
+    value.events.every(isRrwebEvent)
+  )
+}
+
+function withReplayDefaults<T extends ReplayTargetOptions, R>(options: {
+  relayPort: number
+  defaultPage: Page
+  fn: (opts: T & { page: Page; relayPort: number; sessionId?: string }) => Promise<R>
+}): (input?: T) => Promise<R> {
+  const { relayPort, defaultPage, fn } = options
+  return async (input: T = {} as T) => {
+    const targetPage = input.page || defaultPage
+    const sessionId = input.sessionId || targetPage.sessionId() || undefined
+    return await fn({ page: targetPage, sessionId, relayPort, ...input })
+  }
+}
+
+export function createReplayApi(options: CreateReplayApiOptions): {
+  start: (opts?: StartReplayWithDefaultsOptions) => Promise<ReplayState>
+  stop: (opts?: StopReplayWithDefaultsOptions) => Promise<{
+    id?: string
+    path: string
+    duration: number
+    size: number
+    eventCount: number
+  }>
+  isRecording: (opts?: IsReplayWithDefaultsOptions) => Promise<ReplayState>
+  cancel: (opts?: CancelReplayWithDefaultsOptions) => Promise<void>
+  list: (opts?: { limit?: number }) => Promise<SavedReplayRecording[]>
+  events: (opts: { id: string }) => Promise<ReplayRecordingEventsResponse>
+} {
+  const { relayPort, defaultPage } = options
+  return {
+    start: withReplayDefaults<StartReplayWithDefaultsOptions, ReplayState>({
+      relayPort,
+      defaultPage,
+      fn: startReplayRecording,
+    }),
+    stop: withReplayDefaults<
+      StopReplayWithDefaultsOptions,
+      { id?: string; path: string; duration: number; size: number; eventCount: number }
+    >({
+      relayPort,
+      defaultPage,
+      fn: stopReplayRecording,
+    }),
+    isRecording: withReplayDefaults<IsReplayWithDefaultsOptions, ReplayState>({
+      relayPort,
+      defaultPage,
+      fn: isReplayRecording,
+    }),
+    cancel: withReplayDefaults<CancelReplayWithDefaultsOptions, void>({
+      relayPort,
+      defaultPage,
+      fn: cancelReplayRecording,
+    }),
+    list: async (opts) => {
+      return await listReplayRecordings({ ...opts, relayPort })
+    },
+    events: async (opts) => {
+      return await getReplayRecordingEvents({ ...opts, relayPort })
+    },
+  }
+}
+
+export async function startReplayRecording(options: StartReplayOptions): Promise<ReplayState> {
+  const {
+    sessionId,
+    outputPath,
+    relayPort = 19988,
+    checkoutEveryNms,
+    maskAllInputs,
+    recordCanvas,
+    inlineImages,
+    collectFonts,
+    mousemoveWait,
+  } = options
+  const absoluteOutputPath = outputPath ? path.resolve(outputPath) : undefined
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+
+  const response = await fetch(`${relayBaseUrl}/rrweb-recording/start`, {
+    method: 'POST',
+    headers: replayHeaders(),
+    body: JSON.stringify({
+      sessionId,
+      outputPath: absoluteOutputPath,
+      checkoutEveryNms,
+      maskAllInputs,
+      recordCanvas,
+      inlineImages,
+      collectFonts,
+      mousemoveWait,
+    }),
+  })
+  const result = (await response.json()) as StartRrwebRecordingResult
+  if (!result.success) {
+    throw new Error(`Failed to start replay recording: ${result.error}`)
+  }
+  return {
+    isRecording: true,
+    startedAt: result.startedAt,
+    tabId: result.tabId,
+    url: result.url,
+  }
+}
+
+export async function stopReplayRecording(
+  options: StopReplayOptions,
+): Promise<{ id?: string; path: string; duration: number; size: number; eventCount: number }> {
+  const { sessionId, relayPort = 19988 } = options
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+
+  const response = await fetch(`${relayBaseUrl}/rrweb-recording/stop`, {
+    method: 'POST',
+    headers: replayHeaders(),
+    body: JSON.stringify({ sessionId }),
+  })
+  const result = (await response.json()) as StopRrwebRecordingResult
+  if (!result.success) {
+    throw new Error(`Failed to stop replay recording: ${result.error}`)
+  }
+  return { id: result.id, path: result.path, duration: result.duration, size: result.size, eventCount: result.eventCount }
+}
+
+export async function isReplayRecording(options: {
+  page: Page
+  sessionId?: string
+  relayPort?: number
+}): Promise<ReplayState> {
+  const { sessionId, relayPort = 19988 } = options
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+  const url = new URL(`${relayBaseUrl}/rrweb-recording/status`)
+  if (sessionId) {
+    url.searchParams.set('sessionId', sessionId)
+  }
+  const response = await fetch(url.toString(), { headers: replayHeaders() })
+  const result = (await response.json()) as IsRrwebRecordingResult
+  return { isRecording: result.isRecording, startedAt: result.startedAt, tabId: result.tabId, url: result.url }
+}
+
+export async function cancelReplayRecording(options: {
+  page: Page
+  sessionId?: string
+  relayPort?: number
+}): Promise<void> {
+  const { sessionId, relayPort = 19988 } = options
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+
+  const response = await fetch(`${relayBaseUrl}/rrweb-recording/cancel`, {
+    method: 'POST',
+    headers: replayHeaders(),
+    body: JSON.stringify({ sessionId }),
+  })
+  const result = (await response.json()) as CancelRrwebRecordingResult
+  if (!result.success) {
+    throw new Error(`Failed to cancel replay recording: ${result.error}`)
+  }
+}
+
+export async function listReplayRecordings(options: {
+  relayPort?: number
+  limit?: number
+} = {}): Promise<SavedReplayRecording[]> {
+  const { relayPort = 19988, limit = 50 } = options
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+  const url = new URL(`${relayBaseUrl}/rrweb-recordings`)
+  url.searchParams.set('limit', String(limit))
+
+  const response = await fetch(url.toString(), { headers: replayHeaders() })
+  const result = (await response.json()) as unknown
+  if (!response.ok || !isListReplayRecordingsResponse(result)) {
+    throw new Error(`Failed to list replay recordings: ${response.status}`)
+  }
+  return result.recordings
+}
+
+export async function getReplayRecordingEvents(options: {
+  id: string
+  relayPort?: number
+}): Promise<ReplayRecordingEventsResponse> {
+  const { id, relayPort = 19988 } = options
+  const relayBaseUrl = await getReplayRelayBaseUrl(relayPort)
+  const response = await fetch(`${relayBaseUrl}/rrweb-recordings/${encodeURIComponent(id)}/events`, {
+    headers: replayHeaders(),
+  })
+  const result = (await response.json()) as unknown
+  if (!response.ok || !isReplayRecordingEventsResponse(result)) {
+    throw new Error(`Failed to load replay recording events: ${response.status}`)
+  }
+  return result
+}

package/src/scoped-fs.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Regression tests for session-scoped filesystem resolution and session cwd reporting.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, expect, test } from 'vitest'
+import { ExecutorManager, type SessionMetadata } from './executor.js'
+import { createScopedFS } from './scoped-fs.js'
+
+function createTempDir(prefix: string): string {
+  const tempRoot = path.join(process.cwd(), 'tmp')
+  fs.mkdirSync(tempRoot, { recursive: true })
+  return fs.mkdtempSync(path.join(tempRoot, prefix))
+}
+
+describe('ScopedFS', () => {
+  test('resolves relative paths from the session cwd instead of the relay cwd', () => {
+    const sessionDir = createTempDir('scoped-fs-session-')
+    const relayDir = createTempDir('scoped-fs-relay-')
+    const originalCwd = process.cwd()
+
+    try {
+      process.chdir(relayDir)
+
+      const scopedFs = createScopedFS([sessionDir], sessionDir)
+      scopedFs.writeFileSync('note.txt', 'hello from session')
+
+      expect(fs.readFileSync(path.join(sessionDir, 'note.txt'), 'utf-8')).toBe('hello from session')
+      expect(fs.existsSync(path.join(relayDir, 'note.txt'))).toBe(false)
+    } finally {
+      process.chdir(originalCwd)
+      fs.rmSync(sessionDir, { recursive: true, force: true })
+      fs.rmSync(relayDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('ExecutorManager.listSessions', () => {
+  test('includes the resolved cwd for each session', () => {
+    const sessionDir = createTempDir('executor-session-')
+    const sessionMetadata: SessionMetadata = {
+      extensionId: 'profile:test',
+      browser: 'Chrome',
+      profile: { email: 'test@example.com', id: 'profile-1' },
+    }
+
+    try {
+      const manager = new ExecutorManager({
+        cdpConfig: { port: 19988 },
+        logger: {
+          log: () => {},
+          error: () => {},
+        },
+      })
+
+      manager.getExecutor({
+        sessionId: '7',
+        cwd: sessionDir,
+        sessionMetadata,
+      })
+
+      expect(manager.listSessions()).toEqual([
+        {
+          id: '7',
+          stateKeys: [],
+          extensionId: 'profile:test',
+          browser: 'Chrome',
+          profile: { email: 'test@example.com', id: 'profile-1' },
+          cwd: sessionDir,
+          connected: false,
+          pageUrl: null,
+          pagesCount: 0,
+        },
+      ])
+    } finally {
+      fs.rmSync(sessionDir, { recursive: true, force: true })
+    }
+  })
+})