create-appraisejs 0.1.10-alpha.8 → 0.2.0-alpha.1

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

@@ -1,87 +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>
-  )
-}
+'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

@@ -1,45 +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>
-    )
+'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/reports/steps/[stepId]/screenshot/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server'
+import { promises as fs, createReadStream } from 'fs'
+import { Readable } from 'stream'
+import prisma from '@/config/db-config'
+import { resolveStoredPath } from '@/lib/automation/paths'
+
+export const runtime = 'nodejs'
+
+export async function GET(_request: Request, { params }: { params: Promise<{ stepId: string }> }) {
+  const { stepId } = await params
+
+  try {
+    const step = await prisma.reportStep.findUnique({
+      where: { id: stepId },
+      select: {
+        screenshotPath: true,
+      },
+    })
+
+    if (!step) {
+      return NextResponse.json({ error: 'Report step not found' }, { status: 404 })
+    }
+
+    if (!step.screenshotPath) {
+      return NextResponse.json({ error: 'Screenshot not available for this step' }, { status: 404 })
+    }
+
+    const screenshotPath = resolveStoredPath(step.screenshotPath)
+
+    try {
+      await fs.access(screenshotPath)
+    } catch {
+      return NextResponse.json({ error: 'Screenshot file not found' }, { status: 404 })
+    }
+
+    return new NextResponse(Readable.toWeb(createReadStream(screenshotPath)) as ReadableStream, {
+      headers: {
+        'Content-Type': 'image/png',
+        'Cache-Control': 'private, max-age=60',
+      },
+    })
+  } catch (error) {
+    console.error(`[ReportScreenshot] Failed to serve screenshot for step ${stepId}:`, error)
+    return NextResponse.json(
+      {
+        error: 'Failed to load screenshot',
+        details: error instanceof Error ? error.message : 'Unknown error',
+      },
+      { status: 500 },
+    )
+  }
+}

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

@@ -3,31 +3,83 @@ import prisma from '@/config/db-config'
 import archiver from 'archiver'
 import { promises as fs } from 'fs'
 import path from 'path'
+import { getAutomationReportRunDir, resolveStoredPath } from '@/lib/automation/paths'
 
 // Ensure this route runs in Node.js runtime (not Edge) for file system access
 export const runtime = 'nodejs'
 
+async function collectRunArtifactFiles(
+  dir: string,
+  baseDir = dir,
+): Promise<Array<{ absolutePath: string; archivePath: string }>> {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true })
+    const files: Array<{ absolutePath: string; archivePath: string }> = []
+
+    for (const entry of entries) {
+      const absolutePath = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        files.push(...(await collectRunArtifactFiles(absolutePath, baseDir)))
+        continue
+      }
+
+      files.push({
+        absolutePath,
+        archivePath: path.relative(baseDir, absolutePath).replace(/\\/g, '/'),
+      })
+    }
+
+    return files
+  } catch {
+    return []
+  }
+}
+
+async function addStoredArtifactFile(
+  archive: ReturnType<typeof archiver>,
+  storedPath: string,
+  archivePath: string,
+  warningLabel: string,
+): Promise<boolean> {
+  try {
+    const resolvedPath = resolveStoredPath(storedPath)
+    await fs.access(resolvedPath)
+    archive.file(resolvedPath, { name: archivePath })
+    return true
+  } catch {
+    console.warn(`[Download] ${warningLabel} not found at path: ${storedPath}`)
+    return false
+  }
+}
+
+function isPathWithinDirectory(targetPath: string, directoryPath: string): boolean {
+  const relativePath = path.relative(directoryPath, targetPath)
+  return relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)
+}
+
 /**
- * GET handler for downloading test run logs and traces as a zip file
+ * GET handler for downloading a test run's stored artifacts 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)
+ * - Collects the run folder artifacts when present
+ * - Falls back to legacy log/trace paths for older runs
  * - 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 }> }) {
+export async function GET(_request: NextRequest, { params }: { params: Promise<{ runId: string }> }) {
   const { runId } = await params
+  const runArtifactDir = getAutomationReportRunDir(runId)
 
   try {
     // Verify test run exists
     const testRun = await prisma.testRun.findUnique({
       where: { runId },
-      include: {
+      select: {
+        logPath: true,
+        reportPath: true,
         testCases: {
           select: {
-            id: true,
             tracePath: true,
           },
         },
@@ -43,47 +95,59 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       zlib: { level: 9 }, // Maximum compression
     })
 
-    // Track if we have any files to add
-    let hasFiles = false
+    const runArtifactFiles = await collectRunArtifactFiles(runArtifactDir)
+    let hasFiles = runArtifactFiles.length > 0
+    const archivedPaths = new Set<string>(runArtifactFiles.map(artifactFile => artifactFile.archivePath))
+
+    for (const artifactFile of runArtifactFiles) {
+      archive.file(artifactFile.absolutePath, { name: artifactFile.archivePath })
+    }
+
+    if (testRun.reportPath) {
+      const resolvedReportPath = resolveStoredPath(testRun.reportPath)
+      if (!isPathWithinDirectory(resolvedReportPath, runArtifactDir) && !archivedPaths.has('cucumber.json')) {
+        const didAddReportFile = await addStoredArtifactFile(archive, testRun.reportPath, 'cucumber.json', 'Report file')
+        hasFiles = didAddReportFile || hasFiles
+        if (didAddReportFile) {
+          archivedPaths.add('cucumber.json')
+        }
+      }
+    }
 
-    // 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}`)
+      const resolvedLogPath = resolveStoredPath(testRun.logPath)
+      const archivePath = `logs/${path.basename(testRun.logPath)}`
+      if (!isPathWithinDirectory(resolvedLogPath, runArtifactDir) && !archivedPaths.has(archivePath)) {
+        const didAddLogFile = await addStoredArtifactFile(archive, testRun.logPath, archivePath, 'Log file')
+        hasFiles = didAddLogFile || hasFiles
+        if (didAddLogFile) {
+          archivedPaths.add(archivePath)
+        }
       }
     }
 
-    // Add trace files if they exist
-    const traceFiles = testRun.testCases.filter(tc => tc.tracePath).map(tc => tc.tracePath!)
+    const traceFiles = testRun.testCases.flatMap(({ tracePath }) => (tracePath ? [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}`)
+      const resolvedTracePath = resolveStoredPath(tracePath)
+      const archivePath = `traces/${path.basename(tracePath)}`
+
+      if (!isPathWithinDirectory(resolvedTracePath, runArtifactDir) && !archivedPaths.has(archivePath)) {
+        const didAddTraceFile = await addStoredArtifactFile(archive, tracePath, archivePath, 'Trace file')
+        hasFiles = didAddTraceFile || hasFiles
+        if (didAddTraceFile) {
+          archivedPaths.add(archivePath)
+        }
       }
     }
 
     // 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 },
-      )
+      return NextResponse.json({ error: 'No run artifacts 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) => {
@@ -95,7 +159,7 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
         resolve(zipBuffer)
       })
 
-      archive.on('error', (err) => {
+      archive.on('error', err => {
         reject(err)
       })
     })
@@ -130,4 +194,3 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     )
   }
 }
-

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

@@ -312,6 +312,8 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
         scenarioName: string
         status: string
         tracePath?: string
+        featureName?: string
+        scenarioTags?: string[]
       }) => {
         // Early return if error occurred to prevent infinite loops
         if (errorOccurred) return
@@ -325,7 +327,9 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
           sendSSE(
             'scenario::end',
             JSON.stringify({
+              featureName: eventData.featureName,
               scenarioName: eventData.scenarioName,
+              scenarioTags: eventData.scenarioTags,
               status: eventData.status,
               tracePath: eventData.tracePath,
             }),
@@ -418,4 +422,3 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     },
   })
 }
-