create-appraise 0.1.0

package/templates/default/src/app/(dashboard-components)/ongoing-test-runs-card.tsx

@@ -0,0 +1,87 @@
+'use client'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardTitle, CardHeader } from '@/components/ui/card'
+import { ExternalLink } from 'lucide-react'
+import { useRouter } from 'next/navigation'
+import { useEffect, useState, useRef } from 'react'
+import { getRunningTestRunsCountAction } from '@/actions/dashboard/dashboard-actions'
+
+interface OngoingTestRunsCardProps {
+  initialCount: number
+  link: string
+}
+
+export default function OngoingTestRunsCard({ initialCount, link }: OngoingTestRunsCardProps) {
+  const router = useRouter()
+  const [count, setCount] = useState(initialCount)
+  const pollingRef = useRef<NodeJS.Timeout | null>(null)
+
+  // Poll for count updates while there are ongoing test runs
+  useEffect(() => {
+    // Clear any existing polling interval
+    if (pollingRef.current) {
+      clearInterval(pollingRef.current)
+      pollingRef.current = null
+    }
+
+    // If no ongoing test runs, don't poll
+    if (count === 0) {
+      return
+    }
+
+    pollingRef.current = setInterval(async () => {
+      try {
+        const { data, error } = await getRunningTestRunsCountAction()
+        if (error) {
+          console.error('Error polling running test runs count:', error)
+          return
+        }
+
+        const newCount = data as number
+        setCount(newCount)
+
+        // If count reaches 0, stop polling
+        if (newCount === 0 && pollingRef.current) {
+          clearInterval(pollingRef.current)
+          pollingRef.current = null
+        }
+      } catch (error) {
+        console.error('Error polling running test runs count:', error)
+      }
+    }, 2000) // Poll every 2 seconds
+
+    return () => {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current)
+        pollingRef.current = null
+      }
+    }
+  }, [count])
+
+  return (
+    <Card className="h-fit border-gray-600/10 bg-gray-600/10 min-w-40">
+      <CardHeader className="flex items-center justify-between flex-row p-2">
+        <CardTitle className={`text-xs font-normal ${count > 0 ? 'text-primary' : 'text-gray-400'}`}>
+          Ongoing Test Runs
+        </CardTitle>
+        <div className="flex items-center gap-2">
+          <Button
+            variant="outline"
+            className="text-primary hover:text-primary/80 px-2 py-1 bg-inherit border-gray-600/15 hover:bg-emerald-400/10"
+            disabled={count === 0}
+            onClick={() => router.push(link)}
+            size="sm"
+          >
+            <ExternalLink className="h-4 w-4" />
+          </Button>
+        </div>
+      </CardHeader>
+      <CardContent className="h-full px-2 py-1">
+        <div className={`text-2xl h-full flex items-center font-bold ${count > 0 ? 'text-primary' : 'text-gray-400'}`}>
+          {count}
+        </div>
+      </CardContent>
+    </Card>
+  )
+}

package/templates/default/src/app/(dashboard-components)/quick-actions-drawer.tsx

@@ -0,0 +1,45 @@
+'use client'
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { Blocks, FileCheck, LayoutTemplate, ListChecks, TestTubeDiagonal, TestTubes } from "lucide-react";
+import { useRouter } from "next/navigation";
+
+export default function QuickActionsDrawer() {
+    const router = useRouter()
+    return (
+        <Card id="container" className="w-fit border-gray-600/10 bg-gray-600/10 h-fit">
+            <CardHeader id="header">
+                <CardTitle className="text-primary">Quick Actions</CardTitle>
+                <CardDescription>Quickly create new entities to get started</CardDescription>
+            </CardHeader>
+            <CardContent id="content">
+                <div className="grid grid-cols-5 gap-4">
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/test-suites/create')}>
+                        <TestTubes />
+                        <span className="text-xs font-medium">Create Suite</span>
+                    </Button>
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/test-cases/create')}>
+                        <TestTubeDiagonal />
+                        <span className="text-xs font-medium">Create Test</span>
+                    </Button>
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/template-steps/create')}>
+                        <LayoutTemplate />
+                        <span className="text-xs font-medium">Create Step</span>
+                    </Button>
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/test-runs/create')}>
+                        <ListChecks />
+                        <span className="text-xs font-medium">Create Run</span>
+                    </Button>
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/template-test-cases/create')}>
+                        <Blocks />
+                        <span className="text-xs font-medium">Create Template</span>
+                    </Button>
+                    <Button variant="outline" className="flex flex-col items-center gap-2 h-fit [&_svg]:!h-6 [&_svg]:!w-6 bg-emerald-500/10 hover:bg-emerald-500/25 text-emerald-500 hover:text-emerald-400 border-none" onClick={() => router.push('/reports')}>
+                        <FileCheck />
+                        <span className="text-xs font-medium">View Reports</span>
+                    </Button>
+                </div>
+            </CardContent>
+        </Card>
+    )
+}

package/templates/default/src/app/api/test-runs/[runId]/download/route.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from 'next/server'
+import prisma from '@/config/db-config'
+import archiver from 'archiver'
+import { promises as fs } from 'fs'
+import path from 'path'
+
+// Ensure this route runs in Node.js runtime (not Edge) for file system access
+export const runtime = 'nodejs'
+
+/**
+ * GET handler for downloading test run logs and traces as a zip file
+ *
+ * This endpoint:
+ * - Verifies the test run exists
+ * - Collects the log file (if exists)
+ * - Collects all trace files from test cases (if any)
+ * - Creates a zip file containing all files
+ * - Returns the zip file as a downloadable response
+ */
+export async function GET(request: NextRequest, { params }: { params: Promise<{ runId: string }> }) {
+  const { runId } = await params
+
+  try {
+    // Verify test run exists
+    const testRun = await prisma.testRun.findUnique({
+      where: { runId },
+      include: {
+        testCases: {
+          select: {
+            id: true,
+            tracePath: true,
+          },
+        },
+      },
+    })
+
+    if (!testRun) {
+      return NextResponse.json({ error: 'Test run not found' }, { status: 404 })
+    }
+
+    // Create a zip archive
+    const archive = archiver('zip', {
+      zlib: { level: 9 }, // Maximum compression
+    })
+
+    // Track if we have any files to add
+    let hasFiles = false
+
+    // Add log file if it exists
+    if (testRun.logPath) {
+      try {
+        await fs.access(testRun.logPath)
+        const logFileName = path.basename(testRun.logPath)
+        archive.file(testRun.logPath, { name: `logs/${logFileName}` })
+        hasFiles = true
+      } catch {
+        // Log file doesn't exist, skip it
+        console.warn(`[Download] Log file not found at path: ${testRun.logPath}`)
+      }
+    }
+
+    // Add trace files if they exist
+    const traceFiles = testRun.testCases.filter(tc => tc.tracePath).map(tc => tc.tracePath!)
+    for (const tracePath of traceFiles) {
+      try {
+        await fs.access(tracePath)
+        const traceFileName = path.basename(tracePath)
+        archive.file(tracePath, { name: `traces/${traceFileName}` })
+        hasFiles = true
+      } catch {
+        // Trace file doesn't exist, skip it
+        console.warn(`[Download] Trace file not found at path: ${tracePath}`)
+      }
+    }
+
+    // If no files to add, return an error
+    if (!hasFiles) {
+      return NextResponse.json(
+        { error: 'No log or trace files available for this test run' },
+        { status: 404 },
+      )
+    }
+
+    // Create a readable stream to collect the archive data
+    const chunks: Buffer[] = []
+    
+    // Set up event handlers before finalizing
+    const archivePromise = new Promise<Buffer>((resolve, reject) => {
+      archive.on('data', (chunk: Buffer) => {
+        chunks.push(chunk)
+      })
+
+      archive.on('end', () => {
+        const zipBuffer = Buffer.concat(chunks)
+        resolve(zipBuffer)
+      })
+
+      archive.on('error', (err) => {
+        reject(err)
+      })
+    })
+
+    // Finalize the archive
+    archive.finalize()
+
+    // Wait for the archive to complete
+    const zipBuffer = await archivePromise
+
+    // Generate filename with timestamp
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5)
+    const filename = `test-run-${runId}-${timestamp}.zip`
+
+    // Return the zip file as a downloadable response (Uint8Array for BodyInit)
+    return new NextResponse(new Uint8Array(zipBuffer), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/zip',
+        'Content-Disposition': `attachment; filename="${filename}"`,
+        'Content-Length': zipBuffer.length.toString(),
+      },
+    })
+  } catch (error) {
+    console.error(`[Download] Error creating zip file for testRunId: ${runId}:`, error)
+    return NextResponse.json(
+      {
+        error: 'Failed to create download file',
+        details: error instanceof Error ? error.message : 'Unknown error',
+      },
+      { status: 500 },
+    )
+  }
+}
+

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

@@ -0,0 +1,420 @@
+import { NextRequest } from 'next/server'
+import { processManager } from '@/lib/test-run/process-manager'
+import { taskSpawner } from '@/tests/utils/spawner.util'
+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
+      }) => {
+        // 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({
+              scenarioName: eventData.scenarioName,
+              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
+    },
+  })
+}