chore: import upstream snapshot with attribution

apps/sim/app/api/jobs/[jobId]/route.test.ts

@@ -0,0 +1,100 @@
+/**
+ * @vitest-environment node
+ */
+import { hybridAuthMockFns, workflowsUtilsMock, workflowsUtilsMockFns } from '@sim/testing'
+import { NextRequest } from 'next/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGetJobQueue, mockAuthorizeWorkflow, mockGetJob } = vi.hoisted(() => ({
+  mockGetJobQueue: vi.fn(),
+  mockAuthorizeWorkflow: vi.fn(),
+  mockGetJob: vi.fn(),
+}))
+
+vi.mock('@/lib/core/async-jobs', () => ({
+  getJobQueue: mockGetJobQueue,
+}))
+
+vi.mock('@sim/platform-authz/workflow', () => ({
+  authorizeWorkflowByWorkspacePermission: mockAuthorizeWorkflow,
+}))
+
+vi.mock('@/lib/workflows/utils', () => workflowsUtilsMock)
+
+import { GET } from './route'
+
+function createMockRequest(): NextRequest {
+  return new NextRequest(new URL('http://localhost:3000/api/jobs/test'))
+}
+
+describe('GET /api/jobs/[jobId]', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    hybridAuthMockFns.mockCheckHybridAuth.mockResolvedValue({
+      success: true,
+      userId: 'user-1',
+      apiKeyType: undefined,
+      workspaceId: undefined,
+    })
+
+    mockAuthorizeWorkflow.mockResolvedValue({ allowed: true, status: 200 })
+    workflowsUtilsMockFns.mockGetWorkflowById.mockResolvedValue({
+      id: 'workflow-1',
+      workspaceId: 'workspace-1',
+    })
+
+    mockGetJobQueue.mockResolvedValue({
+      getJob: mockGetJob,
+    })
+  })
+
+  it('returns job status with metadata', async () => {
+    mockGetJob.mockResolvedValue({
+      id: 'job-1',
+      status: 'pending',
+      metadata: {
+        workflowId: 'workflow-1',
+      },
+    })
+
+    const response = await GET(createMockRequest(), {
+      params: Promise.resolve({ jobId: 'job-1' }),
+    })
+    const body = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(body.status).toBe('pending')
+    expect(body.metadata.workflowId).toBe('workflow-1')
+  })
+
+  it('returns completed output from job', async () => {
+    mockGetJob.mockResolvedValue({
+      id: 'job-2',
+      status: 'completed',
+      metadata: {
+        workflowId: 'workflow-1',
+      },
+      output: { success: true },
+    })
+
+    const response = await GET(createMockRequest(), {
+      params: Promise.resolve({ jobId: 'job-2' }),
+    })
+    const body = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(body.status).toBe('completed')
+    expect(body.output).toEqual({ success: true })
+  })
+
+  it('returns 404 when job does not exist', async () => {
+    mockGetJob.mockResolvedValue(null)
+
+    const response = await GET(createMockRequest(), {
+      params: Promise.resolve({ jobId: 'missing-job' }),
+    })
+
+    expect(response.status).toBe(404)
+  })
+})

apps/sim/app/api/jobs/[jobId]/route.ts

@@ -0,0 +1,90 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getJobStatusContract } from '@/lib/api/contracts/common'
+import { parseRequest } from '@/lib/api/server'
+import { checkHybridAuth } from '@/lib/auth/hybrid'
+import { getJobQueue } from '@/lib/core/async-jobs'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { createErrorResponse } from '@/app/api/workflows/utils'
+
+const logger = createLogger('TaskStatusAPI')
+
+export const GET = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<{ jobId: string }> }) => {
+    const parsed = await parseRequest(getJobStatusContract, request, context)
+    if (!parsed.success) return parsed.response
+    const { jobId: taskId } = parsed.data.params
+    const requestId = generateRequestId()
+
+    try {
+      const authResult = await checkHybridAuth(request, { requireWorkflowId: false })
+      if (!authResult.success || !authResult.userId) {
+        logger.warn(`[${requestId}] Unauthorized task status request`)
+        return createErrorResponse(authResult.error || 'Authentication required', 401)
+      }
+
+      const authenticatedUserId = authResult.userId
+
+      const jobQueue = await getJobQueue()
+      const job = await jobQueue.getJob(taskId)
+
+      if (!job) {
+        return createErrorResponse('Task not found', 404)
+      }
+
+      const metadataToCheck = job.metadata
+
+      if (metadataToCheck?.workflowId) {
+        const { authorizeWorkflowByWorkspacePermission } = await import(
+          '@sim/platform-authz/workflow'
+        )
+        const accessCheck = await authorizeWorkflowByWorkspacePermission({
+          userId: authenticatedUserId,
+          workflowId: metadataToCheck.workflowId as string,
+          action: 'read',
+        })
+        if (!accessCheck.allowed) {
+          logger.warn(`[${requestId}] Access denied to workflow ${metadataToCheck.workflowId}`)
+          return createErrorResponse('Access denied', 403)
+        }
+
+        if (authResult.apiKeyType === 'workspace' && authResult.workspaceId) {
+          const { getWorkflowById } = await import('@/lib/workflows/utils')
+          const workflow = await getWorkflowById(metadataToCheck.workflowId as string)
+          if (!workflow?.workspaceId || workflow.workspaceId !== authResult.workspaceId) {
+            return createErrorResponse('API key is not authorized for this workspace', 403)
+          }
+        }
+      } else if (metadataToCheck?.userId && metadataToCheck.userId !== authenticatedUserId) {
+        logger.warn(`[${requestId}] Access denied to user ${metadataToCheck.userId}`)
+        return createErrorResponse('Access denied', 403)
+      } else if (!metadataToCheck?.userId && !metadataToCheck?.workflowId) {
+        logger.warn(`[${requestId}] Access denied to job ${taskId}`)
+        return createErrorResponse('Access denied', 403)
+      }
+
+      const response: Record<string, unknown> = {
+        success: true,
+        taskId,
+        status: job.status,
+        metadata: job.metadata,
+      }
+
+      if (job.output !== undefined) response.output = job.output
+      if (job.error !== undefined) response.error = job.error
+
+      return NextResponse.json(response)
+    } catch (error: unknown) {
+      const errorMessage = toError(error).message
+      logger.error(`[${requestId}] Error fetching task status:`, error)
+
+      if (errorMessage?.includes('not found')) {
+        return createErrorResponse('Task not found', 404)
+      }
+
+      return createErrorResponse('Failed to fetch task status', 500)
+    }
+  }
+)