tabwright 1.0.0 → 2.0.0

package/src/cdp-log.test.ts

@@ -1,131 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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,
-  }
-}