feat: staktrak journey pass-fail

fayekelmith · fayekelmith · commit e6950f76e23e · 2026-07-02T17:29:42.000+05:30
diff --git a/src/__tests__/integration/api/tasks-taskid-recording.test.ts b/src/__tests__/integration/api/tasks-taskid-recording.test.ts
@@ -510,6 +510,107 @@ describe("POST /api/tasks/[taskId]/recording - Integration Tests", () => {
       expect(timestampsContent.text).toContain("input");
     });
 
+    test("marks task COMPLETED and message 'passed' when timestamps status is passed", async () => {
+      const validPassword = "test-password";
+      const { task } = await createTestSetup({ agentPassword: validPassword });
+
+      const request = createMultipartRequest(task.id, {
+        apiKey: validPassword,
+        timestampsJson: {
+          testTitle: "sample journey",
+          status: "passed",
+          duration: 3000,
+          actions: [{ title: "click", sourceCode: "await page.click('.button')" }],
+        },
+      });
+
+      const response = await POST(request, { params: Promise.resolve({ taskId: task.id }) });
+      const data = await expectSuccess(response, 201);
+      expect(data.data.testStatus).toBe("passed");
+
+      const message = await db.chatMessage.findUnique({
+        where: { id: data.data.messageId },
+        include: { artifacts: true },
+      });
+      expect(message!.message).toBe("Playwright test passed");
+
+      const media = message!.artifacts.find((a) => a.type === "MEDIA");
+      expect((media!.content as Record<string, unknown>).testStatus).toBe("passed");
+
+      const updatedTask = await db.task.findUnique({
+        where: { id: task.id },
+        select: { workflowStatus: true },
+      });
+      expect(updatedTask!.workflowStatus).toBe("COMPLETED");
+    });
+
+    test("marks task FAILED and surfaces the failing step when timestamps status is failed", async () => {
+      const validPassword = "test-password";
+      const { task } = await createTestSetup({ agentPassword: validPassword });
+
+      const request = createMultipartRequest(task.id, {
+        apiKey: validPassword,
+        timestampsJson: {
+          testTitle: "sample journey",
+          status: "failed",
+          duration: 4200,
+          actions: [
+            { title: "goto", sourceCode: "await page.goto('/')" },
+            {
+              title: "expect",
+              sourceCode: "await expect(el).toBeVisible()",
+              location: { file: "e2e/journey.spec.ts", line: 12, column: 3 },
+              error: { message: "locator not found", stack: "Error: locator not found" },
+            },
+          ],
+        },
+      });
+
+      const response = await POST(request, { params: Promise.resolve({ taskId: task.id }) });
+      const data = await expectSuccess(response, 201);
+      expect(data.data.testStatus).toBe("failed");
+
+      const message = await db.chatMessage.findUnique({
+        where: { id: data.data.messageId },
+        include: { artifacts: true },
+      });
+      expect(message!.message).toBe("Playwright test failed");
+
+      const media = message!.artifacts.find((a) => a.type === "MEDIA");
+      const content = media!.content as Record<string, unknown>;
+      expect(content.testStatus).toBe("failed");
+      expect(content.failedStep).toMatchObject({
+        sourceCode: "await expect(el).toBeVisible()",
+        message: "locator not found",
+      });
+
+      const updatedTask = await db.task.findUnique({
+        where: { id: task.id },
+        select: { workflowStatus: true },
+      });
+      expect(updatedTask!.workflowStatus).toBe("FAILED");
+    });
+
+    test("treats a timedOut status as a failure", async () => {
+      const validPassword = "test-password";
+      const { task } = await createTestSetup({ agentPassword: validPassword });
+
+      const request = createMultipartRequest(task.id, {
+        apiKey: validPassword,
+        timestampsJson: { status: "timedOut", actions: [] },
+      });
+
+      const response = await POST(request, { params: Promise.resolve({ taskId: task.id }) });
+      const data = await expectSuccess(response, 201);
+      expect(data.data.testStatus).toBe("timedOut");
+
+      const updatedTask = await db.task.findUnique({
+        where: { id: task.id },
+        select: { workflowStatus: true },
+      });
+      expect(updatedTask!.workflowStatus).toBe("FAILED");
+    });
+
     test("invalidates agentPassword after successful upload", async () => {
       const validPassword = "test-password";
       const { task } = await createTestSetup({ agentPassword: validPassword });
diff --git a/src/app/api/tasks/[taskId]/recording/route.ts b/src/app/api/tasks/[taskId]/recording/route.ts
@@ -35,14 +35,78 @@ import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { getS3Service } from "@/services/s3";
 import { EncryptionService } from "@/lib/encryption";
-import { ChatRole, ChatStatus, ArtifactType } from "@prisma/client";
+import { ChatRole, ChatStatus, ArtifactType, WorkflowStatus } from "@prisma/client";
 import { validateVideoSize, getMaxVideoSizeMB } from "@/lib/video-validation";
 import { timingSafeEqual } from "@/lib/encryption";
 
 export const fetchCache = "force-no-store";
 
 const encryptionService = EncryptionService.getInstance();
 
+type DerivedTestOutcome = {
+  // Raw Playwright status ("passed" | "failed" | "timedOut" | "interrupted" | "skipped")
+  rawStatus: string | null;
+  outcome: "passed" | "failed" | null;
+  workflowStatus: WorkflowStatus | null;
+  failedStep: { sourceCode?: string; location?: unknown; message?: string } | null;
+};
+
+/**
+ * Derive a pass/fail result from the timestamps.json that staklink uploads with the
+ * recording. Its Playwright reporter writes a top-level `status` per test plus per-step
+ * `actions[].error` (see staklink playwright.ts TimestampReporter). We map that to a task
+ * workflow status so authoritative pod replays surface a real pass/fail instead of being
+ * stuck IN_PROGRESS. Legacy payloads without a `status` leave the task status untouched.
+ */
+export function deriveTestOutcome(timestampsJson: unknown): DerivedTestOutcome {
+  const entries = Array.isArray(timestampsJson) ? timestampsJson : [timestampsJson];
+  let anyKnown = false;
+  let anyFailed = false;
+  let rawStatus: string | null = null;
+  let failedStep: DerivedTestOutcome["failedStep"] = null;
+
+  for (const entry of entries) {
+    const status =
+      entry && typeof (entry as { status?: unknown }).status === "string"
+        ? ((entry as { status: string }).status)
+        : null;
+    if (!status) continue;
+    anyKnown = true;
+    const normalized = status.toLowerCase();
+    if (normalized === "passed" || normalized === "skipped") continue;
+
+    // failed | timedOut | interrupted -> failure
+    anyFailed = true;
+    rawStatus = status;
+    const actions = (entry as { actions?: unknown }).actions;
+    if (!failedStep && Array.isArray(actions)) {
+      const errored = actions.find(
+        (a) => a && typeof a === "object" && (a as { error?: unknown }).error,
+      ) as { sourceCode?: string; location?: unknown; error?: { message?: string } } | undefined;
+      if (errored) {
+        failedStep = {
+          sourceCode: errored.sourceCode,
+          location: errored.location,
+          message: errored.error?.message,
+        };
+      }
+    }
+  }
+
+  if (!anyKnown) {
+    return { rawStatus: null, outcome: null, workflowStatus: null, failedStep: null };
+  }
+  if (anyFailed) {
+    return { rawStatus, outcome: "failed", workflowStatus: WorkflowStatus.FAILED, failedStep };
+  }
+  return {
+    rawStatus: "passed",
+    outcome: "passed",
+    workflowStatus: WorkflowStatus.COMPLETED,
+    failedStep: null,
+  };
+}
+
 export async function POST(request: NextRequest, { params }: { params: Promise<{ taskId: string }> }) {
   console.log("Recording webhook received");
   try {
@@ -143,6 +207,15 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: "Invalid timestamps JSON" }, { status: 400 });
     }
 
+    // Step 4b: Derive pass/fail from the Playwright timestamps
+    const outcome = deriveTestOutcome(timestampsJson);
+    const recordingMessage =
+      outcome.outcome === "passed"
+        ? "Playwright test passed"
+        : outcome.outcome === "failed"
+          ? "Playwright test failed"
+          : "Playwright recording uploaded";
+
     // Step 5: Get Swarm for S3 Path
     const swarm = await db.swarm.findUnique({
       where: { workspaceId: task.workspaceId },
@@ -174,7 +247,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       chatMessage = await db.chatMessage.create({
         data: {
           taskId,
-          message: "Playwright recording uploaded",
+          message: recordingMessage,
           role: ChatRole.ASSISTANT,
           status: ChatStatus.SENT,
           artifacts: {
@@ -189,6 +262,8 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
                   contentType: "video/webm",
                   duration: null,
                   uploadedAt: new Date().toISOString(),
+                  testStatus: outcome.rawStatus,
+                  failedStep: outcome.failedStep,
                 },
                 icon: "video",
               },
@@ -212,11 +287,16 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return NextResponse.json({ error: "Internal error" }, { status: 500 });
     }
 
-    // Step 8: Invalidate API Key (One-time Use)
+    // Step 8: Invalidate API Key (One-time Use) + record pass/fail on the task.
+    // When the timestamps carry a Playwright status, transition the task out of
+    // IN_PROGRESS so an authoritative pod replay surfaces a real result.
     try {
       await db.task.update({
         where: { id: taskId },
-        data: { agentPassword: null },
+        data: {
+          agentPassword: null,
+          ...(outcome.workflowStatus ? { workflowStatus: outcome.workflowStatus } : {}),
+        },
       });
     } catch (error) {
       console.error("Failed to invalidate API key:", error);
@@ -231,6 +311,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
           s3Key: s3Key,
           messageId: chatMessage.id,
           artifactIds: chatMessage.artifacts.map((a) => a.id),
+          testStatus: outcome.rawStatus,
         },
       },
       { status: 201 },
