feat(block): Allow wait block to wait up to 30 days

apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts

@@ -145,6 +145,7 @@ export const POST = withRouteHandler(
         contextId,
         resumeInput,
         userId,
+        allowedPauseKinds: ['human'],
       })
 
       if (enqueueResult.status === 'queued') {

apps/sim/app/api/resume/poll/route.ts

@@ -0,0 +1,175 @@
+import { db } from '@sim/db'
+import { pausedExecutions } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { generateShortId } from '@sim/utils/id'
+import { and, asc, eq, isNotNull, lte } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { verifyCronAuth } from '@/lib/auth/internal'
+import { acquireLock, releaseLock } from '@/lib/core/config/redis'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import {
+  computeEarliestResumeAt,
+  PauseResumeManager,
+} from '@/lib/workflows/executor/human-in-the-loop-manager'
+import type { PausePoint } from '@/executor/types'
+
+const logger = createLogger('TimePauseResumePoll')
+
+export const dynamic = 'force-dynamic'
+export const maxDuration = 120
+
+const LOCK_KEY = 'time-pause-resume-poll-lock'
+const LOCK_TTL_SECONDS = 180
+const POLL_BATCH_LIMIT = 200
+
+interface DispatchFailure {
+  executionId: string
+  contextId: string
+  error: string
+}
+
+interface RowResult {
+  dispatched: number
+  failures: DispatchFailure[]
+}
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateShortId()
+
+  const authError = verifyCronAuth(request, 'Time-pause resume poll')
+  if (authError) return authError
+
+  const lockAcquired = await acquireLock(LOCK_KEY, requestId, LOCK_TTL_SECONDS)
+  if (!lockAcquired) {
+    return NextResponse.json(
+      { success: true, message: 'Polling already in progress – skipped', requestId },
+      { status: 202 }
+    )
+  }
+
+  try {
+    const now = new Date()
+
+    const dueRows = await db
+      .select({
+        id: pausedExecutions.id,
+        executionId: pausedExecutions.executionId,
+        workflowId: pausedExecutions.workflowId,
+        pausePoints: pausedExecutions.pausePoints,
+        metadata: pausedExecutions.metadata,
+      })
+      .from(pausedExecutions)
+      .where(
+        and(
+          eq(pausedExecutions.status, 'paused'),
+          isNotNull(pausedExecutions.nextResumeAt),
+          lte(pausedExecutions.nextResumeAt, now)
+        )
+      )
+      .orderBy(asc(pausedExecutions.nextResumeAt))
+      .limit(POLL_BATCH_LIMIT)
+
+    const results = await Promise.all(dueRows.map((row) => dispatchRow(row, now)))
+    const dispatched = results.reduce((sum, r) => sum + r.dispatched, 0)
+    const failures = results.flatMap((r) => r.failures)
+
+    logger.info('Time-pause resume poll completed', {
+      requestId,
+      claimedRows: dueRows.length,
+      dispatched,
+      failureCount: failures.length,
+    })
+
+    return NextResponse.json({
+      success: true,
+      requestId,
+      claimedRows: dueRows.length,
+      dispatched,
+      failures,
+    })
+  } catch (error) {
+    const message = toError(error).message
+    logger.error('Time-pause resume poll failed', { requestId, error: message })
+    return NextResponse.json({ success: false, requestId, error: message }, { status: 500 })
+  } finally {
+    await releaseLock(LOCK_KEY, requestId).catch(() => {})
+  }
+})
+
+interface DueRow {
+  id: string
+  executionId: string
+  workflowId: string
+  pausePoints: unknown
+  metadata: unknown
+}
+
+async function dispatchRow(row: DueRow, now: Date): Promise<RowResult> {
+  const points = (row.pausePoints ?? {}) as Record<string, PausePoint>
+  const metadata = (row.metadata ?? {}) as Record<string, unknown>
+  const userId = typeof metadata.executorUserId === 'string' ? metadata.executorUserId : ''
+
+  const eligiblePoints = Object.values(points).filter(
+    (point) =>
+      point.pauseKind === 'time' && (!point.resumeStatus || point.resumeStatus === 'paused')
+  )
+  const duePoints = eligiblePoints.filter((point) => {
+    if (!point.resumeAt) return false
+    const at = new Date(point.resumeAt)
+    return !Number.isNaN(at.getTime()) && at <= now
+  })
+
+  const failures: DispatchFailure[] = []
+  let dispatched = 0
+
+  for (const point of duePoints) {
+    if (!point.contextId) continue
+    try {
+      const enqueueResult = await PauseResumeManager.enqueueOrStartResume({
+        executionId: row.executionId,
+        contextId: point.contextId,
+        resumeInput: {},
+        userId,
+        allowedPauseKinds: ['time'],
+      })
+
+      if (enqueueResult.status === 'starting') {
+        PauseResumeManager.startResumeExecution({
+          resumeEntryId: enqueueResult.resumeEntryId,
+          resumeExecutionId: enqueueResult.resumeExecutionId,
+          pausedExecution: enqueueResult.pausedExecution,
+          contextId: enqueueResult.contextId,
+          resumeInput: enqueueResult.resumeInput,
+          userId: enqueueResult.userId,
+        }).catch((error) => {
+          logger.error('Background time-pause resume failed', {
+            executionId: row.executionId,
+            contextId: point.contextId,
+            error: toError(error).message,
+          })
+        })
+      }
+      dispatched++
+    } catch (error) {
+      const message = toError(error).message
+      logger.warn('Failed to dispatch time-pause resume', {
+        executionId: row.executionId,
+        contextId: point.contextId,
+        error: message,
+      })
+      failures.push({ executionId: row.executionId, contextId: point.contextId, error: message })
+    }
+  }
+
+  // We never auto-retry a failed dispatch: workflow blocks aren't idempotent, and
+  // an operator must investigate stranded rows by hand. The status='paused' guard
+  // also prevents clobbering when a concurrent manual resume has already advanced
+  // the row's state since we read it.
+  await PauseResumeManager.setNextResumeAt({
+    pausedExecutionId: row.id,
+    nextResumeAt: computeEarliestResumeAt(eligiblePoints, { after: now }),
+  })
+
+  return { dispatched, failures }
+}

apps/sim/app/resume/[workflowId]/[executionId]/resume-page-client.tsx

@@ -88,6 +88,8 @@ interface PausePointWithQueue {
   latestResumeEntry?: ResumeQueueEntrySummary | null
   parallelScope?: any
   loopScope?: any
+  pauseKind?: 'human' | 'time'
+  resumeAt?: string
 }
 
 interface PausedExecutionSummary {

apps/sim/blocks/blocks/wait.ts

@@ -8,13 +8,14 @@ const WaitIcon = (props: SVGProps<SVGSVGElement>) => createElement(PauseCircle,
 export const WaitBlock: BlockConfig = {
   type: 'wait',
   name: 'Wait',
-  description: 'Pause workflow execution for a specified time delay',
+  description: 'Pause workflow execution for up to 30 days',
   longDescription:
-    'Pauses workflow execution for a specified time interval. The wait executes a simple sleep for the configured duration.',
+    'Pauses workflow execution for a specified time interval. Waits up to five minutes are held in-process; longer waits suspend the workflow and resume automatically once the configured duration elapses.',
   bestPractices: `
-  - Use for simple time delays (max 10 minutes)
-  - Configure the wait amount and unit (seconds or minutes)
-  - Time-based waits are interruptible via workflow cancellation
+  - Configure the wait amount and unit (seconds, minutes, hours, or days)
+  - Maximum wait duration is 30 days
+  - Waits up to 5 minutes execute in-process and are interruptible via workflow cancellation
+  - Longer waits suspend the workflow; the execution resumes automatically when the timer fires
   - Enter a positive number for the wait amount
   `,
   category: 'blocks',
@@ -26,7 +27,7 @@ export const WaitBlock: BlockConfig = {
       id: 'timeValue',
       title: 'Wait Amount',
       type: 'short-input',
-      description: 'Max: 600 seconds or 10 minutes',
+      description: 'Max: 30 days',
       placeholder: '10',
       value: () => '10',
       required: true,
@@ -38,6 +39,8 @@ export const WaitBlock: BlockConfig = {
       options: [
         { label: 'Seconds', id: 'seconds' },
         { label: 'Minutes', id: 'minutes' },
+        { label: 'Hours', id: 'hours' },
+        { label: 'Days', id: 'days' },
       ],
       value: () => 'seconds',
       required: true,
@@ -53,7 +56,7 @@ export const WaitBlock: BlockConfig = {
     },
     timeUnit: {
       type: 'string',
-      description: 'Wait duration unit (seconds or minutes)',
+      description: 'Wait duration unit (seconds, minutes, hours, or days)',
     },
   },
   outputs: {
@@ -65,5 +68,9 @@ export const WaitBlock: BlockConfig = {
       type: 'string',
       description: 'Status of the wait block (waiting, completed, cancelled)',
     },
+    resumeAt: {
+      type: 'string',
+      description: 'ISO timestamp at which a suspended wait will resume (long waits only)',
+    },
   },
 }

apps/sim/executor/execution/engine.ts

@@ -484,6 +484,8 @@ export class ExecutionEngine {
       parallelScope: pause.parallelScope,
       loopScope: pause.loopScope,
       resumeLinks: pause.resumeLinks,
+      pauseKind: pause.pauseKind,
+      resumeAt: pause.resumeAt,
     }))
 
     return {

apps/sim/executor/handlers/human-in-the-loop/human-in-the-loop-handler.ts

@@ -188,6 +188,7 @@ export class HumanInTheLoopBlockHandler implements BlockHandler {
         parallelScope,
         loopScope,
         resumeLinks,
+        pauseKind: 'human',
       }
 
       const responseOutput: Record<string, any> = {