chore: merge main into release for new releases

Author: tofikwest

apps/app/src/app/(app)/[orgId]/cloud-tests/actions/run-platform-scan.ts

@@ -1,13 +1,17 @@
 'use server';
 
 import { auth } from '@/utils/auth';
+import { runs, tasks } from '@trigger.dev/sdk';
 import { revalidatePath } from 'next/cache';
 import { headers } from 'next/headers';
 
+const MAX_POLL_ATTEMPTS = 150; // Max 5 minutes (150 * 2 seconds)
+const POLL_INTERVAL_MS = 2000;
+
 /**
  * Run cloud security scan for a new platform connection.
- * This server action calls the API and properly revalidates the cache,
- * ensuring consistent behavior with the legacy runTests action.
+ * Triggers a Trigger.dev background task and polls for completion,
+ * avoiding ALB/gateway timeouts on long-running scans.
  *
  * @param connectionId - The IntegrationConnection ID (icn_...) to scan
  */
@@ -32,48 +36,71 @@ export const runPlatformScan = async (connectionId: string) => {
   }
 
   try {
-    // Call the cloud security scan API
-    const apiUrl = process.env.NEXT_PUBLIC_API_URL || process.env.API_URL;
-    if (!apiUrl) {
-      return {
-        success: false,
-        error: 'API URL not configured',
-      };
-    }
-
-    const response = await fetch(`${apiUrl}/v1/cloud-security/scan/${connectionId}`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-organization-id': orgId,
-      },
+    // Trigger the scan as a background task (same pattern as legacy runTests)
+    // This avoids ALB/gateway timeouts on long-running Azure/AWS scans
+    const handle = await tasks.trigger('run-cloud-security-scan', {
+      connectionId,
+      organizationId: orgId,
+      providerSlug: 'platform',
+      connectionName: connectionId,
     });
 
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        success: false,
-        error: errorData.message || `Scan failed with status ${response.status}`,
-      };
-    }
+    // Poll for completion
+    let attempts = 0;
+    while (attempts < MAX_POLL_ATTEMPTS) {
+      const run = await runs.retrieve(handle.id);
+
+      if (run.isCompleted) {
+        // Revalidate cache
+        const headersList = await headers();
+        let path = headersList.get('x-pathname') || headersList.get('referer') || '';
+        path = path.replace(/\/[a-z]{2}\//, '/');
+        if (path) {
+          revalidatePath(path);
+        }
+        revalidatePath(`/${orgId}/cloud-tests`);
 
-    const result = await response.json();
+        if (run.isSuccess) {
+          const output = run.output as {
+            success?: boolean;
+            error?: string;
+            findingsCount?: number;
+            provider?: string;
+            scannedAt?: string;
+          } | null;
 
-    // Revalidate the cloud-tests page to refresh data
-    const headersList = await headers();
-    let path = headersList.get('x-pathname') || headersList.get('referer') || '';
-    path = path.replace(/\/[a-z]{2}\//, '/');
-    if (path) {
-      revalidatePath(path);
+          if (output?.success === false) {
+            return {
+              success: false,
+              error: output.error || 'Scan completed with errors',
+            };
+          }
+
+          return {
+            success: true,
+            findingsCount: output?.findingsCount,
+            provider: output?.provider,
+            scannedAt: output?.scannedAt,
+          };
+        }
+
+        return {
+          success: false,
+          error: 'Scan task failed or was canceled',
+        };
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      attempts++;
     }
-    // Also revalidate the org's cloud-tests path specifically
+
+    // Polling timeout - the scan is still running in the background
+    // Revalidate anyway so fresh data shows on next page load
     revalidatePath(`/${orgId}/cloud-tests`);
 
     return {
-      success: true,
-      findingsCount: result.findingsCount,
-      provider: result.provider,
-      scannedAt: result.scannedAt,
+      success: false,
+      error: 'Scan is taking longer than expected. Results will appear when complete.',
     };
   } catch (error) {
     console.error('Error running platform scan:', error);