create-appraisejs 0.3.0-alpha.0 → 0.3.0-alpha.1

package/templates/starter/src/app/api/test-runs/[runId]/logs/route.ts

@@ -0,0 +1,424 @@
+import { NextRequest } from 'next/server'
+import { processManager } from '@/lib/test-run/process-manager'
+import { taskSpawner } from '@/lib/process/task-spawner'
+import prisma from '@/config/db-config'
+import { TestRunStatus } from '@prisma/client'
+
+// Ensure this route runs in Node.js runtime (not Edge) for singleton to work
+export const runtime = 'nodejs'
+
+/**
+ * Server-Sent Events (SSE) route handler for streaming test run logs
+ *
+ * This endpoint streams logs from a running test process to the client
+ * using Server-Sent Events. It listens to TaskSpawner stdout/stderr events
+ * and forwards them as SSE messages.
+ *
+ * Security: Verifies test run exists in database before allowing access.
+ * TODO: Add user authentication check when authentication is implemented.
+ */
+export async function GET(request: NextRequest, { params }: { params: Promise<{ runId: string }> }) {
+  const { runId } = await params
+
+  // Verify test run exists in database and check status
+  // TODO: Add user authentication check here when authentication is implemented
+  // Example: where: { runId, userId: currentUser.id }
+  try {
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      select: { id: true, status: true }, // Need status to check if completed
+    })
+
+    if (!testRun) {
+      console.error(`[SSE] Test run not found in database for runId: ${runId}`)
+      const errorStream = new ReadableStream({
+        start(controller) {
+          const encoder = new TextEncoder()
+          const message = `event: error\ndata: ${JSON.stringify({ error: 'Test run not found' })}\n\n`
+          controller.enqueue(encoder.encode(message))
+          setTimeout(() => {
+            controller.close()
+          }, 100)
+        },
+      })
+
+      return new Response(errorStream, {
+        status: 404,
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache, no-transform',
+          Connection: 'keep-alive',
+        },
+      })
+    }
+
+    // If test run is completed, reject SSE connection - logs should be loaded from DB
+    if (testRun.status === TestRunStatus.COMPLETED || testRun.status === TestRunStatus.CANCELLED) {
+      console.log(`[SSE] Test run ${runId} is ${testRun.status}, rejecting SSE connection`)
+      const errorStream = new ReadableStream({
+        start(controller) {
+          const encoder = new TextEncoder()
+          const message = `event: error\ndata: ${JSON.stringify({ error: 'Test run has completed. Logs are available in the database.' })}\n\n`
+          controller.enqueue(encoder.encode(message))
+          setTimeout(() => {
+            controller.close()
+          }, 100)
+        },
+      })
+
+      return new Response(errorStream, {
+        status: 200, // Return 200 but with error event so client can handle it
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache, no-transform',
+          Connection: 'keep-alive',
+        },
+      })
+    }
+  } catch (error) {
+    console.error(`[SSE] Database error verifying test run for runId: ${runId}:`, error)
+    const errorStream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder()
+        const message = `event: error\ndata: ${JSON.stringify({ error: 'Internal server error' })}\n\n`
+        controller.enqueue(encoder.encode(message))
+        setTimeout(() => {
+          controller.close()
+        }, 100)
+      },
+    })
+
+    return new Response(errorStream, {
+      status: 500,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+
+  // Wait for process to be registered (with timeout)
+  // This handles the race condition where the page loads before the process is spawned
+  let process = processManager.get(runId)
+  const maxWaitTime = 10000 // Increase to 10 seconds
+  const checkInterval = 200 // Check every 200ms
+  let waited = 0
+
+  console.log(`[SSE] Looking for process with runId: ${runId}, current processes: ${processManager.size()}`)
+
+  // Log all available process IDs for debugging
+  if (processManager.size() > 0) {
+    const availableProcesses = processManager.getAllTestRunIds()
+    console.log(`[SSE] Available process IDs:`, availableProcesses)
+    console.log(`[SSE] Looking for runId: "${runId}", available:`, availableProcesses.map(id => `"${id}"`).join(', '))
+  } else {
+    console.log(`[SSE] No processes registered yet. ProcessManager size: ${processManager.size()}`)
+  }
+
+  while (!process && waited < maxWaitTime) {
+    await new Promise(resolve => setTimeout(resolve, checkInterval))
+    waited += checkInterval
+    process = processManager.get(runId)
+
+    // Log progress every 2 seconds
+    if (waited % 2000 === 0) {
+      console.log(`[SSE] Still waiting for process ${runId}... (${waited}ms elapsed)`)
+    }
+  }
+
+  if (!process) {
+    const availableProcesses = processManager.getAllTestRunIds()
+    const errorMessage = `Process not found for runId: ${runId} after ${waited}ms. Available processes: ${processManager.size()}. Available IDs: ${availableProcesses.join(', ') || 'none'}`
+    console.error(`[SSE] ${errorMessage}`)
+
+    // Return an SSE stream with an error event instead of JSON response
+    // This allows EventSource to properly handle the error
+    const errorStream = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder()
+        const message = `event: error\ndata: ${JSON.stringify({
+          error: 'Test run process not found. The process may not have started yet or may have already completed.',
+          details: `Looking for: ${runId}, Available: ${availableProcesses.join(', ') || 'none'}`,
+        })}\n\n`
+        controller.enqueue(encoder.encode(message))
+        setTimeout(() => {
+          controller.close()
+        }, 100)
+      },
+    })
+
+    return new Response(errorStream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+
+  // Process found, proceed with SSE connection
+
+  // Store cleanup function reference for cancel handler
+  let cleanupRef: (() => void) | null = null
+
+  // Create a ReadableStream for SSE
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder()
+      let isClosed = false
+      let errorOccurred = false
+      let errorLogged = false // Track if we've already logged the error to avoid spam
+
+      /**
+       * Helper function to safely close the controller
+       */
+      const safeClose = () => {
+        if (!isClosed) {
+          try {
+            controller.close()
+            isClosed = true
+          } catch {
+            // Controller may already be closed
+          }
+        }
+      }
+
+      /**
+       * Helper function to send SSE message
+       * Flushes immediately to ensure real-time streaming
+       */
+      const sendSSE = (event: string, data: string) => {
+        // Early return if stream is closed or error occurred
+        if (isClosed || errorOccurred) return
+
+        try {
+          const message = `event: ${event}\ndata: ${data}\n\n`
+          controller.enqueue(encoder.encode(message))
+        } catch (error) {
+          // Only log error once to avoid infinite spam
+          if (!errorLogged) {
+            console.error(`[SSE] Error sending ${event} event:`, error)
+            errorLogged = true
+          }
+
+          // Mark error occurred and immediately cleanup
+          errorOccurred = true
+          isClosed = true
+
+          // Immediately cleanup listeners to prevent further events
+          cleanup()
+          safeClose()
+        }
+      }
+
+      /**
+       * Check if a line is an event JSON (should not be displayed in logs)
+       */
+      const isEventJson = (line: string): boolean => {
+        try {
+          const trimmed = line.trim()
+          if (!trimmed.startsWith('{') || !trimmed.includes('"event"')) {
+            return false
+          }
+          const parsed = JSON.parse(trimmed)
+          return parsed.event === 'scenario::end' || parsed.event !== undefined
+        } catch {
+          return false
+        }
+      }
+
+      /**
+       * Handler for stdout events
+       */
+      const onStdout = ({ processName, data }: { processName: string; data: string }) => {
+        // Early return if error occurred to prevent infinite loops
+        if (errorOccurred) return
+
+        if (processName === process.name) {
+          // Filter out event JSON lines - they're for internal processing only
+          const lines = data.split('\n')
+          const filteredLines = lines.filter(line => {
+            const trimmed = line.trim()
+            return trimmed && !isEventJson(trimmed)
+          })
+
+          if (filteredLines.length > 0) {
+            sendSSE('log', JSON.stringify({ type: 'stdout', message: filteredLines.join('\n') }))
+          }
+        }
+      }
+
+      /**
+       * Handler for stderr events
+       */
+      const onStderr = ({ processName, data }: { processName: string; data: string }) => {
+        // Early return if error occurred to prevent infinite loops
+        if (errorOccurred) return
+
+        if (processName === process.name) {
+          // Filter out event JSON lines - they're for internal processing only
+          const lines = data.split('\n')
+          const filteredLines = lines.filter(line => {
+            const trimmed = line.trim()
+            return trimmed && !isEventJson(trimmed)
+          })
+
+          if (filteredLines.length > 0) {
+            sendSSE('log', JSON.stringify({ type: 'stderr', message: filteredLines.join('\n') }))
+          }
+        }
+      }
+
+      /**
+       * Handler for process exit
+       */
+      const onExit = ({ processName, code }: { processName: string; code: number | null }) => {
+        // Early return if error occurred to prevent infinite loops
+        if (errorOccurred) {
+          // Still cleanup on exit even if error occurred
+          cleanup()
+          safeClose()
+          return
+        }
+
+        if (processName === process.name) {
+          sendSSE('exit', JSON.stringify({ code }))
+          // Close the stream after sending exit event
+          setTimeout(() => {
+            cleanup()
+            safeClose()
+          }, 100)
+        }
+      }
+
+      /**
+       * Handler for process errors
+       */
+      const onError = ({ processName, error }: { processName: string; error: Error }) => {
+        // Early return if error occurred to prevent infinite loops
+        if (errorOccurred) return
+
+        if (processName === process.name) {
+          sendSSE('error', JSON.stringify({ message: error.message }))
+        }
+      }
+
+      /**
+       * Handler for scenario::end events from ProcessManager
+       */
+      const onScenarioEnd = (eventData: {
+        testRunId: string
+        scenarioName: string
+        status: string
+        tracePath?: string
+        featureName?: string
+        scenarioTags?: string[]
+      }) => {
+        // Early return if error occurred to prevent infinite loops
+        if (errorOccurred) return
+
+        console.log(
+          `[SSE] Received scenario::end event for testRunId: ${eventData.testRunId}, runId: ${runId}`,
+          eventData,
+        )
+        if (eventData.testRunId === runId) {
+          console.log(`[SSE] Sending scenario::end SSE event for scenario: ${eventData.scenarioName}`)
+          sendSSE(
+            'scenario::end',
+            JSON.stringify({
+              featureName: eventData.featureName,
+              scenarioName: eventData.scenarioName,
+              scenarioTags: eventData.scenarioTags,
+              status: eventData.status,
+              tracePath: eventData.tracePath,
+            }),
+          )
+        } else {
+          console.log(`[SSE] Ignoring scenario::end event - testRunId mismatch: ${eventData.testRunId} !== ${runId}`)
+        }
+      }
+
+      // Clean up listeners helper (defined before use)
+      const cleanup = () => {
+        taskSpawner.removeListener('stdout', onStdout)
+        taskSpawner.removeListener('stderr', onStderr)
+        taskSpawner.removeListener('exit', onExit)
+        taskSpawner.removeListener('error', onError)
+        processManager.removeListener('scenario::end', onScenarioEnd)
+      }
+
+      // Store cleanup reference for cancel handler
+      cleanupRef = cleanup
+
+      // Set up event listeners on TaskSpawner
+      taskSpawner.on('stdout', onStdout)
+      taskSpawner.on('stderr', onStderr)
+      taskSpawner.on('exit', onExit)
+      taskSpawner.on('error', onError)
+
+      // Listen for scenario::end events from ProcessManager
+      processManager.on('scenario::end', onScenarioEnd)
+
+      console.log(`[SSE] Connected to log stream for runId: ${runId}`)
+
+      // Send initial connection message
+      sendSSE('connected', JSON.stringify({ message: 'Connected to log stream' }))
+
+      // Send any already captured output immediately (filter out event JSON)
+      if (process.output && (process.output.stdout.length > 0 || process.output.stderr.length > 0)) {
+        process.output.stdout.forEach(line => {
+          const trimmed = line.trim()
+          // Skip event JSON lines
+          if (trimmed && !isEventJson(trimmed)) {
+            sendSSE('log', JSON.stringify({ type: 'stdout', message: line }))
+          }
+        })
+        process.output.stderr.forEach(line => {
+          const trimmed = line.trim()
+          // Skip event JSON lines
+          if (trimmed && !isEventJson(trimmed)) {
+            sendSSE('log', JSON.stringify({ type: 'stderr', message: line }))
+          }
+        })
+      }
+
+      // Check if process has already exited (race condition check after listeners are set up)
+      // We check this after setting up listeners in case exit event was emitted during setup
+      if (!process.isRunning && process.exitCode !== null) {
+        sendSSE('exit', JSON.stringify({ code: process.exitCode }))
+        // Don't close immediately - let any pending events be sent first
+        setTimeout(() => {
+          cleanup()
+          safeClose()
+        }, 500)
+        return
+      }
+
+      // Handle client disconnect
+      request.signal.addEventListener('abort', () => {
+        errorOccurred = true
+        cleanup()
+        safeClose()
+      })
+    },
+    cancel() {
+      // Handle stream cancellation (client closes connection)
+      // Cleanup listeners if they were set up
+      if (cleanupRef) {
+        cleanupRef()
+        cleanupRef = null
+      }
+    },
+  })
+
+  // Return SSE response with appropriate headers
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no', // Disable nginx buffering
+    },
+  })
+}

package/templates/starter/src/app/api/test-runs/[runId]/trace/[testCaseId]/route.test.ts

@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { NextRequest } from 'next/server'
+
+const { mockAccess, mockFindUnique, mockGetProcess, mockSpawn } = vi.hoisted(() => ({
+  mockAccess: vi.fn(),
+  mockFindUnique: vi.fn(),
+  mockGetProcess: vi.fn(),
+  mockSpawn: vi.fn(),
+}))
+
+vi.mock('fs', () => ({
+  promises: {
+    access: mockAccess,
+  },
+}))
+
+vi.mock('@/config/db-config', () => ({
+  default: {
+    testRun: {
+      findUnique: mockFindUnique,
+    },
+  },
+}))
+
+vi.mock('@/lib/process/task-spawner', () => ({
+  taskSpawner: {
+    getProcess: mockGetProcess,
+    spawn: mockSpawn,
+  },
+}))
+
+vi.mock('@/lib/automation/automation-path-roots', () => ({
+  resolveStoredPath: vi.fn((storedPath: string) => `/resolved/${storedPath}`),
+}))
+
+import { GET, POST } from './route'
+
+describe('trace route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns 404 when the run is missing on GET', async () => {
+    mockFindUnique.mockResolvedValue(null)
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Test run not found' })
+  })
+
+  it('returns 404 when the test case is not part of the run on GET', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [],
+    })
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Test case not found in this test run' })
+  })
+
+  it('returns viewer status when the process exists on GET', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1' }],
+    })
+    mockGetProcess.mockReturnValue({ isRunning: true })
+
+    const response = await GET(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1'), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      isRunning: true,
+      processName: 'trace-viewer-trtc-1',
+    })
+  })
+
+  it('returns 400 when no trace path is stored on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: null }],
+    })
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(400)
+    await expect(response.json()).resolves.toEqual({ error: 'No trace path available for this test case' })
+  })
+
+  it('returns 404 when the trace file is missing on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: 'trace.zip', testCase: { id: 'tc-1' } }],
+    })
+    mockAccess.mockRejectedValue(new Error('missing'))
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toEqual({ error: 'Trace file not found at path: trace.zip' })
+  })
+
+  it('spawns the trace viewer when the trace file exists on POST', async () => {
+    mockFindUnique.mockResolvedValue({
+      testCases: [{ id: 'trtc-1', tracePath: 'trace.zip', testCase: { id: 'tc-1' } }],
+    })
+    mockAccess.mockResolvedValue(undefined)
+    mockSpawn.mockResolvedValue({ name: 'trace-viewer-trtc-1' })
+
+    const response = await POST(new NextRequest('http://localhost/api/test-runs/run-1/trace/trtc-1', { method: 'POST' }), {
+      params: Promise.resolve({ runId: 'run-1', testCaseId: 'trtc-1' }),
+    })
+
+    expect(mockSpawn).toHaveBeenCalledWith('npx', ['playwright', 'show-trace', '/resolved/trace.zip'], {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: 'trace-viewer-trtc-1',
+      captureOutput: false,
+    })
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      success: true,
+      message: 'Trace viewer launched successfully',
+      processName: 'trace-viewer-trtc-1',
+    })
+  })
+})

package/templates/starter/src/app/api/test-runs/[runId]/trace/[testCaseId]/route.ts

@@ -0,0 +1,146 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { promises as fs } from 'fs'
+import { taskSpawner } from '@/lib/process/task-spawner'
+import prisma from '@/config/db-config'
+import { resolveStoredPath } from '@/lib/automation/automation-path-roots'
+
+// Ensure this route runs in Node.js runtime (not Edge) for singleton to work
+export const runtime = 'nodejs'
+
+/**
+ * GET handler for checking if trace viewer is running
+ *
+ * This endpoint checks if a trace viewer process is currently running for a test case.
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
+) {
+  const { runId, testCaseId } = await params
+
+  try {
+    // Verify test run exists
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      include: {
+        testCases: {
+          where: { id: testCaseId },
+        },
+      },
+    })
+
+    if (!testRun) {
+      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    // Verify test case belongs to this test run
+    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
+    if (!testRunTestCase) {
+      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
+    }
+
+    // Check if trace viewer process is running
+    const processName = `trace-viewer-${testCaseId}`
+    const process = taskSpawner.getProcess(processName)
+    const isRunning = process?.isRunning ?? false
+
+    return NextResponse.json({
+      isRunning,
+      processName: isRunning ? processName : null,
+    })
+  } catch (error) {
+    console.error(
+      `[TraceViewer] Error checking trace viewer status for runId: ${runId}, testCaseId: ${testCaseId}:`,
+      error,
+    )
+    return NextResponse.json(
+      {
+        error: `Failed to check trace viewer status: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 500 },
+    )
+  }
+}
+
+/**
+ * POST handler for spawning Playwright trace viewer
+ *
+ * This endpoint spawns a process to open the Playwright trace viewer for a failed test scenario.
+ * The process is self-closing and doesn't require cleanup.
+ *
+ * Security: Verifies test run and test case exist and belong together before allowing access.
+ * TODO: Add user authentication check when authentication is implemented.
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ runId: string; testCaseId: string }> },
+) {
+  const { runId, testCaseId } = await params
+
+  try {
+    // Verify test run exists
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      include: {
+        testCases: {
+          where: { id: testCaseId },
+          include: {
+            testCase: true,
+          },
+        },
+      },
+    })
+
+    if (!testRun) {
+      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    // Verify test case belongs to this test run
+    const testRunTestCase = testRun.testCases.find(tc => tc.id === testCaseId)
+    if (!testRunTestCase) {
+      return NextResponse.json({ error: 'Test case not found in this test run' }, { status: 404 })
+    }
+
+    // Get trace path from database
+    const tracePath = testRunTestCase.tracePath
+    if (!tracePath) {
+      return NextResponse.json({ error: 'No trace path available for this test case' }, { status: 400 })
+    }
+
+    const absoluteTracePath = resolveStoredPath(tracePath)
+
+    // Validate trace file exists
+    try {
+      await fs.access(absoluteTracePath)
+    } catch {
+      return NextResponse.json({ error: `Trace file not found at path: ${tracePath}` }, { status: 404 })
+    }
+
+    // Spawn playwright show-trace command
+    // The process is self-closing when the user closes the trace viewer
+    const spawnedProcess = await taskSpawner.spawn('npx', ['playwright', 'show-trace', absoluteTracePath], {
+      streamLogs: true,
+      prefixLogs: true,
+      logPrefix: `trace-viewer-${testCaseId}`,
+      captureOutput: false, // No need to capture output for trace viewer
+    })
+
+    console.log(
+      `[TraceViewer] Spawned trace viewer process for testCaseId: ${testCaseId}, tracePath: ${absoluteTracePath}`,
+    )
+
+    return NextResponse.json({
+      success: true,
+      message: 'Trace viewer launched successfully',
+      processName: spawnedProcess.name,
+    })
+  } catch (error) {
+    console.error(`[TraceViewer] Error spawning trace viewer for runId: ${runId}, testCaseId: ${testCaseId}:`, error)
+    return NextResponse.json(
+      {
+        error: `Failed to spawn trace viewer: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 500 },
+    )
+  }
+}