tabwright 1.0.0

package/src/cdp-log.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect } from 'vitest'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { createCdpLogger, type CdpLogEntry } from './cdp-log.js'
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'cdp-log-test-'))
+}
+
+function makeEntry(i: number): CdpLogEntry {
+  return {
+    timestamp: new Date().toISOString(),
+    direction: 'from-extension',
+    message: { method: `Test.method${i}`, id: i },
+  }
+}
+
+function readIds(logFile: string): number[] {
+  return fs
+    .readFileSync(logFile, 'utf-8')
+    .trim()
+    .split('\n')
+    .filter((l) => {
+      return l.length > 0
+    })
+    .map((l) => {
+      return JSON.parse(l).message.id as number
+    })
+}
+
+describe('CDP log rotation', () => {
+  it('rotates when lineCount exceeds maxEntries, keeping last half', async () => {
+    const tmpDir = makeTmpDir()
+    const logFile = path.join(tmpDir, 'cdp.jsonl')
+    const logger = createCdpLogger({ logFilePath: logFile, maxEntries: 20 })
+
+    // Write 25 entries to trigger rotation (threshold is 20)
+    for (let i = 0; i < 25; i++) {
+      logger.log(makeEntry(i))
+    }
+    await logger.flush()
+
+    const ids = readIds(logFile)
+
+    // Rotation triggers after entry 20 is written (lineCount becomes 21 > 20).
+    // It keeps last 10 (entries 11-20), then entries 21-24 are appended.
+    expect(ids).toMatchInlineSnapshot(`
+      [
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20,
+        21,
+        22,
+        23,
+        24,
+      ]
+    `)
+
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  it('does not rotate when under maxEntries', async () => {
+    const tmpDir = makeTmpDir()
+    const logFile = path.join(tmpDir, 'cdp.jsonl')
+    const logger = createCdpLogger({ logFilePath: logFile, maxEntries: 50 })
+
+    for (let i = 0; i < 30; i++) {
+      logger.log(makeEntry(i))
+    }
+    await logger.flush()
+
+    const ids = readIds(logFile)
+    expect(ids.length).toBe(30)
+    expect(ids[0]).toBe(0)
+    expect(ids[29]).toBe(29)
+
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  it('handles multiple rotations', async () => {
+    const tmpDir = makeTmpDir()
+    const logFile = path.join(tmpDir, 'cdp.jsonl')
+    const logger = createCdpLogger({ logFilePath: logFile, maxEntries: 10 })
+
+    // Write 35 entries, should trigger multiple rotations
+    for (let i = 0; i < 35; i++) {
+      logger.log(makeEntry(i))
+    }
+    await logger.flush()
+
+    const ids = readIds(logFile)
+
+    // File should never exceed maxEntries
+    expect(ids.length).toBeLessThanOrEqual(15)
+    expect(ids.length).toBeGreaterThanOrEqual(5)
+
+    // Last entry should always be the most recent
+    expect(ids[ids.length - 1]).toBe(34)
+    // No entries from the very beginning should survive multiple rotations
+    expect(ids[0]).toBeGreaterThan(10)
+
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  it('uses atomic rename for rotation', async () => {
+    const tmpDir = makeTmpDir()
+    const logFile = path.join(tmpDir, 'cdp.jsonl')
+    const logger = createCdpLogger({ logFilePath: logFile, maxEntries: 10 })
+
+    for (let i = 0; i < 15; i++) {
+      logger.log(makeEntry(i))
+    }
+    await logger.flush()
+
+    // Temp file should not remain after successful rotation
+    expect(fs.existsSync(`${logFile}.tmp`)).toBe(false)
+
+    const ids = readIds(logFile)
+    expect(ids[ids.length - 1]).toBe(14)
+
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+})

package/src/cdp-log.ts

@@ -0,0 +1,112 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { LOG_CDP_FILE_PATH } from './utils.js'
+
+export type CdpLogEntry = {
+  timestamp: string
+  direction: 'from-playwright' | 'to-playwright' | 'from-extension' | 'to-extension'
+  clientId?: string
+  source?: 'extension' | 'server'
+  message: unknown
+}
+
+export type CdpLogger = {
+  log(entry: CdpLogEntry): void
+  /** Wait for all pending writes (and any in-flight rotation) to complete */
+  flush(): Promise<void>
+  logFilePath: string
+}
+
+const DEFAULT_MAX_STRING_LENGTH = Number(
+  process.env.TABWRIGHT_CDP_LOG_MAX_STRING_LENGTH || process.env.PLAYWRITER_CDP_LOG_MAX_STRING_LENGTH || 2000,
+)
+
+function truncateString(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value
+  }
+  const truncatedCount = value.length - maxLength
+  return `${value.slice(0, maxLength)}…[truncated ${truncatedCount} chars]`
+}
+
+function createTruncatingReplacer({ maxStringLength }: { maxStringLength: number }) {
+  const seen = new WeakSet<object>()
+  return (_key: string, value: unknown) => {
+    if (typeof value === 'string') {
+      return truncateString(value, maxStringLength)
+    }
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return '[Circular]'
+      }
+      seen.add(value)
+    }
+    return value
+  }
+}
+
+const DEFAULT_MAX_ENTRIES = 10_000
+
+function resolvePositiveInt(value: number | undefined, fallback: number): number {
+  if (value == null || !Number.isFinite(value) || value < 2) {
+    return fallback
+  }
+  return Math.floor(value)
+}
+
+export function createCdpLogger({
+  logFilePath,
+  maxStringLength,
+  maxEntries,
+}: { logFilePath?: string; maxStringLength?: number; maxEntries?: number } = {}): CdpLogger {
+  const resolvedLogFilePath = logFilePath || LOG_CDP_FILE_PATH
+  const logDir = path.dirname(resolvedLogFilePath)
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true })
+  }
+  fs.writeFileSync(resolvedLogFilePath, '')
+
+  let queue: Promise<void> = Promise.resolve()
+  let lineCount = 0
+  const maxLength = maxStringLength ?? DEFAULT_MAX_STRING_LENGTH
+  const envMaxEntries = Number(process.env.TABWRIGHT_CDP_LOG_MAX_ENTRIES || process.env.PLAYWRITER_CDP_LOG_MAX_ENTRIES)
+  const resolvedMaxEntries = resolvePositiveInt(maxEntries, resolvePositiveInt(envMaxEntries, DEFAULT_MAX_ENTRIES))
+  // Keep half the entries after rotation so we don't rotate on every write
+  const keepAfterRotation = Math.floor(resolvedMaxEntries / 2)
+
+  // Atomic rotation: write to temp file then rename to avoid corruption on crash
+  const rotate = async (): Promise<void> => {
+    try {
+      const content = await fs.promises.readFile(resolvedLogFilePath, 'utf-8')
+      const lines = content.split('\n').filter((l) => {
+        return l.length > 0
+      })
+      const kept = lines.slice(-keepAfterRotation)
+      const tmpPath = `${resolvedLogFilePath}.tmp`
+      await fs.promises.writeFile(tmpPath, kept.join('\n') + '\n')
+      await fs.promises.rename(tmpPath, resolvedLogFilePath)
+      lineCount = kept.length
+    } catch {
+      // If rotation fails (disk error, permissions), keep logging without rotation.
+      // lineCount stays high so rotation will be retried on next write.
+    }
+  }
+
+  const log = (entry: CdpLogEntry): void => {
+    const replacer = createTruncatingReplacer({ maxStringLength: maxLength })
+    const line = JSON.stringify(entry, replacer)
+    queue = queue.then(async () => {
+      await fs.promises.appendFile(resolvedLogFilePath, `${line}\n`)
+      lineCount++
+      if (lineCount > resolvedMaxEntries) {
+        await rotate()
+      }
+    })
+  }
+
+  return {
+    log,
+    flush: () => queue,
+    logFilePath: resolvedLogFilePath,
+  }
+}