feat(api): v2 executions status + cancel with queued backfill

GET /api/v2/workflows/[id]/executions/[executionId] is the single
status URL for sync and async runs: before the async worker writes the
durable log row, status is backfilled from the job queue (deterministic
job id) as 'queued'/'running' — closing v1's 202-to-pickup 404 window —
and failed runs carry the structured error object. POST .../cancel
renders the shared cancellation lib in the v2 envelope with the
tightened 5-value reason enum. Both authenticate via the shared
resolveV2WorkflowAccess (X-API-Key, authz masked as 404,
allowPersonalApiKeys honored).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CiHhAk2R1NryaS3R8n2yFz

Author: TheodoreSpeaks

apps/sim/app/api/v2/workflows/[id]/executions/[executionId]/cancel/route.ts

@@ -0,0 +1,48 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import type { NextRequest } from 'next/server'
+import { v2CancelWorkflowExecutionContract } from '@/lib/api/contracts/v2/workflows'
+import { parseRequest } from '@/lib/api/server'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { cancelWorkflowExecution } from '@/lib/execution/cancel-workflow-execution'
+import { v2Data, v2Error, v2ValidationError } from '@/app/api/v2/lib/response'
+import { resolveV2WorkflowAccess } from '@/app/api/v2/workflows/lib/access'
+
+const logger = createLogger('V2CancelExecutionAPI')
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+
+/** POST /api/v2/workflows/[id]/executions/[executionId]/cancel */
+export const POST = withRouteHandler(
+  async (req: NextRequest, context: { params: Promise<{ id: string; executionId: string }> }) => {
+    const parsed = await parseRequest(v2CancelWorkflowExecutionContract, req, context, {
+      validationErrorResponse: v2ValidationError,
+    })
+    if (!parsed.success) return parsed.response
+    const { id: workflowId, executionId } = parsed.data.params
+
+    const access = await resolveV2WorkflowAccess(req, workflowId, 'write')
+    if (!access.ok) return access.response
+
+    try {
+      logger.info('Cancel execution requested', { workflowId, executionId, userId: access.userId })
+
+      const result = await cancelWorkflowExecution({
+        executionId,
+        workflowId,
+        userId: access.userId,
+        workspaceId: access.workflow.workspaceId ?? undefined,
+      })
+
+      return v2Data(result)
+    } catch (error) {
+      logger.error('Failed to cancel execution', {
+        workflowId,
+        executionId,
+        error: getErrorMessage(error, 'Unknown error'),
+      })
+      return v2Error('INTERNAL_ERROR', 'Internal server error')
+    }
+  }
+)

apps/sim/app/api/v2/workflows/[id]/executions/[executionId]/route.test.ts

@@ -0,0 +1,171 @@
+/**
+ * @vitest-environment node
+ */
+import { createMockRequest, workflowAuthzMockFns } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockAuthenticateV1Request, mockGetJob, mockGetWorkflowExecutionStatus, mockCancel } =
+  vi.hoisted(() => ({
+    mockAuthenticateV1Request: vi.fn(),
+    mockGetJob: vi.fn(),
+    mockGetWorkflowExecutionStatus: vi.fn(),
+    mockCancel: vi.fn(),
+  }))
+
+vi.mock('@/app/api/v1/auth', () => ({
+  authenticateV1Request: mockAuthenticateV1Request,
+}))
+
+vi.mock('@/lib/workspaces/utils', () => ({
+  getWorkspaceBillingSettings: vi.fn().mockResolvedValue({ allowPersonalApiKeys: true }),
+}))
+
+vi.mock('@/lib/workflows/executor/execution-status', () => ({
+  getWorkflowExecutionStatus: mockGetWorkflowExecutionStatus,
+}))
+
+vi.mock('@/lib/execution/cancel-workflow-execution', () => ({
+  cancelWorkflowExecution: mockCancel,
+}))
+
+vi.mock('@/lib/core/async-jobs', () => ({
+  getJobQueue: vi.fn().mockResolvedValue({ getJob: mockGetJob }),
+}))
+
+vi.mock('@/lib/workflows/executor/enqueue-execution', () => ({
+  WORKFLOW_EXECUTION_JOB_ID_PREFIX: 'workflow-execution:',
+}))
+
+import { POST as cancelPost } from './cancel/route'
+import { GET } from './route'
+
+const mockAuthorize = workflowAuthzMockFns.mockAuthorizeWorkflowByWorkspacePermission
+
+const workflowRecord = {
+  id: 'workflow-1',
+  userId: 'owner-1',
+  workspaceId: 'workspace-1',
+}
+
+function callStatus(query = '') {
+  const req = createMockRequest(
+    'GET',
+    undefined,
+    {},
+    `http://localhost:3000/api/v2/workflows/workflow-1/executions/exec-1${query}`
+  )
+  return GET(req, { params: Promise.resolve({ id: 'workflow-1', executionId: 'exec-1' }) })
+}
+
+describe('v2 executions status + cancel', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockAuthenticateV1Request.mockResolvedValue({
+      authenticated: true,
+      userId: 'key-user-1',
+      keyType: 'workspace',
+      workspaceId: 'workspace-1',
+    })
+    mockAuthorize.mockResolvedValue({ allowed: true, workflow: workflowRecord })
+  })
+
+  it('returns the execution resource with a structured error', async () => {
+    mockGetWorkflowExecutionStatus.mockResolvedValue({
+      executionId: 'exec-1',
+      workflowId: 'workflow-1',
+      status: 'failed',
+      trigger: 'api',
+      level: 'error',
+      startedAt: '2026-07-31T00:00:00.000Z',
+      endedAt: '2026-07-31T00:00:05.000Z',
+      totalDurationMs: 5000,
+      paused: null,
+      cost: { total: 0.02 },
+      error: 'Send Email: Invalid credentials',
+      finalOutput: null,
+      blockOutputs: null,
+    })
+
+    const res = await callStatus()
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.data.status).toBe('failed')
+    expect(body.data.error.code).toBe('EXECUTION_FAILED')
+    expect(body.data.error.message).toBe('Send Email: Invalid credentials')
+    expect(body.data.durationMs).toBe(5000)
+  })
+
+  it('backfills queued status from the job queue before the log row exists', async () => {
+    mockGetWorkflowExecutionStatus.mockResolvedValue(null)
+    mockGetJob.mockResolvedValue({
+      status: 'pending',
+      metadata: { workflowId: 'workflow-1' },
+    })
+
+    const res = await callStatus()
+
+    expect(res.status).toBe(200)
+    expect((await res.json()).data.status).toBe('queued')
+    expect(mockGetJob).toHaveBeenCalledWith('workflow-execution:exec-1')
+  })
+
+  it('404s when neither a log row nor a matching job exists', async () => {
+    mockGetWorkflowExecutionStatus.mockResolvedValue(null)
+    mockGetJob.mockResolvedValue(null)
+
+    const res = await callStatus()
+
+    expect(res.status).toBe(404)
+    expect((await res.json()).error.code).toBe('NOT_FOUND')
+  })
+
+  it('masks cross-workspace access as 404', async () => {
+    mockAuthenticateV1Request.mockResolvedValue({
+      authenticated: true,
+      userId: 'key-user-1',
+      keyType: 'workspace',
+      workspaceId: 'other-workspace',
+    })
+
+    const res = await callStatus()
+
+    expect(res.status).toBe(404)
+    expect(mockGetWorkflowExecutionStatus).not.toHaveBeenCalled()
+  })
+
+  it('cancels through the shared lib and returns the tightened result', async () => {
+    mockCancel.mockResolvedValue({
+      success: true,
+      executionId: 'exec-1',
+      redisAvailable: true,
+      durablyRecorded: true,
+      locallyAborted: false,
+      pausedCancelled: false,
+      reason: 'recorded',
+    })
+
+    const req = createMockRequest('POST', undefined, {})
+    const res = await cancelPost(req, {
+      params: Promise.resolve({ id: 'workflow-1', executionId: 'exec-1' }),
+    })
+
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.data).toMatchObject({ success: true, reason: 'recorded' })
+    expect(mockCancel).toHaveBeenCalledWith({
+      executionId: 'exec-1',
+      workflowId: 'workflow-1',
+      userId: 'key-user-1',
+      workspaceId: 'workspace-1',
+    })
+  })
+
+  it('401s without an API key (no session/anonymous path on executions)', async () => {
+    mockAuthenticateV1Request.mockResolvedValue({ authenticated: false, error: 'API key required' })
+
+    const res = await callStatus()
+
+    expect(res.status).toBe(401)
+  })
+})

apps/sim/app/api/v2/workflows/[id]/executions/[executionId]/route.ts

@@ -0,0 +1,123 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import type { NextRequest } from 'next/server'
+import {
+  type V2WorkflowExecutionStatus,
+  v2GetWorkflowExecutionContract,
+} from '@/lib/api/contracts/v2/workflows'
+import { parseRequest } from '@/lib/api/server'
+import { getJobQueue } from '@/lib/core/async-jobs'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { WORKFLOW_EXECUTION_JOB_ID_PREFIX } from '@/lib/workflows/executor/enqueue-execution'
+import { getWorkflowExecutionStatus } from '@/lib/workflows/executor/execution-status'
+import { v2Data, v2Error, v2ValidationError } from '@/app/api/v2/lib/response'
+import { resolveV2WorkflowAccess } from '@/app/api/v2/workflows/lib/access'
+import { classifyExecutionError } from '@/executor/utils/errors'
+
+const logger = createLogger('V2WorkflowExecutionStatusAPI')
+
+export const dynamic = 'force-dynamic'
+
+/**
+ * Maps the async job's phase onto the execution status enum for the window
+ * before the worker writes the durable log row.
+ */
+function jobStatusToExecutionStatus(jobStatus: string): V2WorkflowExecutionStatus['status'] | null {
+  switch (jobStatus) {
+    case 'pending':
+      return 'queued'
+    case 'processing':
+      return 'running'
+    case 'failed':
+      return 'failed'
+    case 'completed':
+      return 'completed'
+    default:
+      return null
+  }
+}
+
+/**
+ * GET /api/v2/workflows/[id]/executions/[executionId] — the single status URL
+ * for both sync and async runs. When no log row exists yet, the async job
+ * queue is consulted (deterministic job id) so a freshly-queued run reports
+ * `queued` instead of 404.
+ */
+export const GET = withRouteHandler(
+  async (
+    request: NextRequest,
+    context: { params: Promise<{ id: string; executionId: string }> }
+  ) => {
+    const parsed = await parseRequest(v2GetWorkflowExecutionContract, request, context, {
+      validationErrorResponse: v2ValidationError,
+    })
+    if (!parsed.success) return parsed.response
+    const { id: workflowId, executionId } = parsed.data.params
+    const { includeOutput, selectedOutputs } = parsed.data.query
+
+    const access = await resolveV2WorkflowAccess(request, workflowId, 'read')
+    if (!access.ok) return access.response
+
+    try {
+      const status = await getWorkflowExecutionStatus({
+        workflowId,
+        executionId,
+        includeOutput,
+        selectedOutputs,
+      })
+
+      if (status) {
+        return v2Data({
+          executionId: status.executionId,
+          workflowId: status.workflowId,
+          status: status.status,
+          trigger: status.trigger ?? null,
+          startedAt: status.startedAt,
+          endedAt: status.endedAt,
+          durationMs: status.totalDurationMs,
+          paused: status.paused,
+          cost: status.cost,
+          error: status.error ? classifyExecutionError(new Error(status.error)) : null,
+          output: status.finalOutput,
+          blockOutputs: status.blockOutputs,
+        })
+      }
+
+      // No log row yet — a queued/just-started async run. Backfilled from the
+      // job queue via the deterministic id; authz already ran above.
+      const jobQueue = await getJobQueue()
+      const job = await jobQueue.getJob(`${WORKFLOW_EXECUTION_JOB_ID_PREFIX}${executionId}`)
+      const jobWorkflowId =
+        job?.metadata && typeof job.metadata === 'object'
+          ? (job.metadata as { workflowId?: string }).workflowId
+          : undefined
+      const mapped = job ? jobStatusToExecutionStatus(job.status) : null
+      if (!job || jobWorkflowId !== workflowId || !mapped) {
+        return v2Error('NOT_FOUND', 'Execution not found')
+      }
+
+      return v2Data({
+        executionId,
+        workflowId,
+        status: mapped,
+        trigger: 'api',
+        startedAt: null,
+        endedAt: null,
+        durationMs: null,
+        paused: null,
+        cost: null,
+        error:
+          mapped === 'failed' && job.error ? classifyExecutionError(new Error(job.error)) : null,
+        output: null,
+        blockOutputs: null,
+      })
+    } catch (error) {
+      logger.error('Failed to fetch execution status', {
+        workflowId,
+        executionId,
+        error: getErrorMessage(error, 'Unknown error'),
+      })
+      return v2Error('INTERNAL_ERROR', 'Internal server error')
+    }
+  }
+)