fix(slack): finalize custom bot migration rollout

Author: TheodoreSpeaks

apps/sim/blocks/blocks/slack.test.ts

@@ -13,14 +13,12 @@ import {
 const EXTENDED_OPERATION_IDS = ['set_status', 'set_title', 'set_suggested_prompts']
 const EXTENDED_TOOL_IDS = ['slack_set_status', 'slack_set_title', 'slack_set_suggested_prompts']
 
-function operationIds(extendedScopesEnabled: boolean): string[] {
-  const operation = getSlackV2ActionSubBlocks(extendedScopesEnabled).find(
-    (subBlock) => subBlock.id === 'operation'
-  )
+function operationIds(): string[] {
+  const operation = getSlackV2ActionSubBlocks().find((subBlock) => subBlock.id === 'operation')
   return operation?.options?.map((option) => option.id) ?? []
 }
 
-describe('Slack block extended-scope capability', () => {
+describe('Slack block release', () => {
   it('releases slack_v2 and keeps the legacy block executable but hidden', () => {
     expect(SlackBlock.hideFromToolbar).toBe(true)
     expect(SlackBlock.sunset).toEqual({ status: 'legacy', replacedBy: 'slack_v2' })
@@ -29,18 +27,10 @@ describe('Slack block extended-scope capability', () => {
     expect(SlackV2Block.sunset).toBeUndefined()
   })
 
-  it('removes extended-scope operations and tools when the capability is disabled', () => {
-    expect(operationIds(false)).not.toEqual(expect.arrayContaining(EXTENDED_OPERATION_IDS))
-    expect(getSlackV2ToolAccess(false)).not.toEqual(expect.arrayContaining(EXTENDED_TOOL_IDS))
-    expect(Object.keys(getSlackV2OperationSentences(false))).not.toEqual(
-      expect.arrayContaining(EXTENDED_OPERATION_IDS)
-    )
-  })
-
-  it('restores extended-scope operations and tools when the capability is enabled', () => {
-    expect(operationIds(true)).toEqual(expect.arrayContaining(EXTENDED_OPERATION_IDS))
-    expect(getSlackV2ToolAccess(true)).toEqual(expect.arrayContaining(EXTENDED_TOOL_IDS))
-    expect(Object.keys(getSlackV2OperationSentences(true))).toEqual(
+  it('keeps custom-bot operations available independently of native OAuth scopes', () => {
+    expect(operationIds()).toEqual(expect.arrayContaining(EXTENDED_OPERATION_IDS))
+    expect(getSlackV2ToolAccess()).toEqual(expect.arrayContaining(EXTENDED_TOOL_IDS))
+    expect(Object.keys(getSlackV2OperationSentences())).toEqual(
       expect.arrayContaining(EXTENDED_OPERATION_IDS)
     )
   })

apps/sim/blocks/blocks/slack.ts

@@ -1,6 +1,5 @@
 import { BookOpen, ClipboardList, File, Table, Users } from '@sim/emcn/icons'
 import { GoogleTranslateIcon, GreptileIcon, SlackIcon } from '@/components/icons'
-import { isSlackExtendedScopesEnabled } from '@/lib/core/config/env-flags'
 import { getScopesForService } from '@/lib/oauth/utils'
 import type { BlockConfig, BlockMeta, SubBlockConfig } from '@/blocks/types'
 import { AuthMode, IntegrationType } from '@/blocks/types'
@@ -16,18 +15,6 @@ import { getTrigger } from '@/triggers'
 /** The operations that offer a channel/DM switch, and so honour it. */
 const DESTINATION_SWITCH_OPERATIONS = ['send', 'read', 'schedule_message'] as const
 
-const SLACK_EXTENDED_SCOPE_OPERATION_IDS = new Set([
-  'set_status',
-  'set_title',
-  'set_suggested_prompts',
-])
-
-const SLACK_EXTENDED_SCOPE_TOOL_IDS = new Set([
-  'slack_set_status',
-  'slack_set_title',
-  'slack_set_suggested_prompts',
-])
-
 const CHANNEL_FIELD = ['channel', 'manualChannel'] as const
 
 /**
@@ -2934,16 +2921,8 @@ const SLACK_WEBHOOK_TRIGGER_SUBBLOCK_IDS = new Set(
  * Adapts a v1 subblock for slack_v2's merged credential picker: fields gated on
  * the removed `authMethod` dropdown now depend on the single `credential` field.
  */
-function adaptSubBlockForV2(sb: SubBlockConfig, extendedScopesEnabled: boolean): SubBlockConfig {
+function adaptSubBlockForV2(sb: SubBlockConfig): SubBlockConfig {
   const { dependsOn, condition, ...rest } = sb
-  if (sb.id === 'operation' && !extendedScopesEnabled) {
-    const options = typeof sb.options === 'function' ? sb.options() : sb.options
-    if (!options) throw new Error('Slack operation subblock must define options')
-    return {
-      ...sb,
-      options: options.filter((option) => !SLACK_EXTENDED_SCOPE_OPERATION_IDS.has(option.id)),
-    }
-  }
   if (sb.id === 'credential') {
     return {
       ...rest,
@@ -2966,31 +2945,24 @@ function adaptSubBlockForV2(sb: SubBlockConfig, extendedScopesEnabled: boolean):
   return sb
 }
 
-export function getSlackV2ActionSubBlocks(extendedScopesEnabled: boolean): SubBlockConfig[] {
+export function getSlackV2ActionSubBlocks(): SubBlockConfig[] {
   return SlackBlock.subBlocks.flatMap((sb) => {
     if (SLACK_WEBHOOK_TRIGGER_SUBBLOCK_IDS.has(sb.id)) return []
     if (sb.id === 'authMethod') return []
-    return [adaptSubBlockForV2(sb, extendedScopesEnabled)]
+    return [adaptSubBlockForV2(sb)]
   })
 }
 
-export function getSlackV2ToolAccess(extendedScopesEnabled: boolean): string[] {
-  if (extendedScopesEnabled) return [...SlackBlock.tools.access]
-  return SlackBlock.tools.access.filter((toolId) => !SLACK_EXTENDED_SCOPE_TOOL_IDS.has(toolId))
+export function getSlackV2ToolAccess(): string[] {
+  return [...SlackBlock.tools.access]
 }
 
-export function getSlackV2OperationSentences(extendedScopesEnabled: boolean) {
+export function getSlackV2OperationSentences() {
   const operationSentences = SlackBlock.canvasPresentation?.sentences?.byOperation
   if (!operationSentences) {
     throw new Error('Slack action sentences must be defined before building slack_v2')
   }
-  if (extendedScopesEnabled) return { ...operationSentences }
-
-  const scopedSentences = { ...operationSentences }
-  for (const operationId of SLACK_EXTENDED_SCOPE_OPERATION_IDS) {
-    delete scopedSentences[operationId]
-  }
-  return scopedSentences
+  return { ...operationSentences }
 }
 
 const {
@@ -3017,7 +2989,7 @@ export const SlackV2Block: BlockConfig<SlackResponse> = {
     defaultTitle: 'Slack',
     sentences: {
       ...SlackBlock.canvasPresentation?.sentences,
-      byOperation: getSlackV2OperationSentences(isSlackExtendedScopesEnabled),
+      byOperation: getSlackV2OperationSentences(),
     },
     /*
      * Unlike v1, this trigger picks one event and scopes it, so the card names
@@ -3038,13 +3010,10 @@ export const SlackV2Block: BlockConfig<SlackResponse> = {
       ],
     },
   },
-  subBlocks: [
-    ...getSlackV2ActionSubBlocks(isSlackExtendedScopesEnabled),
-    ...getTrigger('slack_oauth').subBlocks,
-  ],
+  subBlocks: [...getSlackV2ActionSubBlocks(), ...getTrigger('slack_oauth').subBlocks],
   tools: {
     ...SlackBlock.tools,
-    access: getSlackV2ToolAccess(isSlackExtendedScopesEnabled),
+    access: getSlackV2ToolAccess(),
   },
   inputs: {
     ...slackV2Inputs,

apps/sim/lib/webhooks/slack-dispatch.test.ts

@@ -0,0 +1,71 @@
+/**
+ * @vitest-environment node
+ */
+import { NextRequest, NextResponse } from 'next/server'
+import { describe, expect, it, vi } from 'vitest'
+
+const { mockDispatchResolvedWebhookTarget } = vi.hoisted(() => ({
+  mockDispatchResolvedWebhookTarget: vi.fn(),
+}))
+
+vi.mock('@/lib/webhooks/processor', () => ({
+  dispatchResolvedWebhookTarget: mockDispatchResolvedWebhookTarget,
+}))
+
+vi.mock('@/lib/webhooks/providers/slack', () => ({
+  resolveSlackEventKey: vi.fn(),
+}))
+
+import { dispatchResolvedWebhookTarget } from '@/lib/webhooks/processor'
+import { dispatchSlackWebhooks } from '@/lib/webhooks/slack-dispatch'
+
+describe('dispatchSlackWebhooks', () => {
+  it('dispatches at most ten targets concurrently and preserves result order', async () => {
+    let active = 0
+    let peak = 0
+    const releases: Array<() => void> = []
+
+    vi.mocked(dispatchResolvedWebhookTarget).mockImplementation(async (foundWebhook) => {
+      active += 1
+      peak = Math.max(peak, active)
+      await new Promise<void>((resolve) => releases.push(resolve))
+      active -= 1
+
+      const index = Number(foundWebhook.id.replace('webhook-', ''))
+      return {
+        outcome: 'queued',
+        response: new NextResponse(null, { status: 200 + index }),
+        reason: 'queued',
+      }
+    })
+
+    const webhooks = Array.from({ length: 12 }, (_, index) => ({
+      webhook: { id: `webhook-${index}`, providerConfig: {} },
+      workflow: { id: `workflow-${index}` },
+    }))
+    const dispatchPromise = dispatchSlackWebhooks(webhooks as never, {
+      body: { event: { type: 'message' } },
+      request: new NextRequest('http://localhost/api/webhooks/slack'),
+      requestId: 'request-1',
+      receivedAt: Date.now(),
+    })
+
+    await vi.waitFor(() => expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(10))
+    expect(active).toBe(10)
+
+    for (let index = 0; index < 10; index += 1) {
+      releases.shift()?.()
+    }
+
+    await vi.waitFor(() => expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(12))
+    while (releases.length > 0) {
+      releases.shift()?.()
+    }
+
+    const results = await dispatchPromise
+    expect(peak).toBe(10)
+    expect(results.map(({ response }) => response.status)).toEqual(
+      Array.from({ length: 12 }, (_, index) => 200 + index)
+    )
+  })
+})

apps/sim/lib/webhooks/slack-dispatch.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
+import { mapWithConcurrency } from '@/lib/core/utils/concurrency'
 import {
   dispatchResolvedWebhookTarget,
   type findWebhooksByRoutingKey,
@@ -8,6 +9,7 @@ import {
 import { resolveSlackEventKey } from '@/lib/webhooks/providers/slack'
 
 const logger = createLogger('SlackWebhookDispatch')
+const SLACK_WEBHOOK_DISPATCH_CONCURRENCY = 10
 
 interface DispatchSlackWebhooksOptions {
   body: unknown
@@ -31,31 +33,41 @@ export async function dispatchSlackWebhooks(
   const slackRequestTimestamp = request.headers.get('x-slack-request-timestamp')
   const parsedTimestampMs = slackRequestTimestamp ? Number(slackRequestTimestamp) * 1000 : undefined
   const triggerTimestampMs = Number.isFinite(parsedTimestampMs) ? parsedTimestampMs : undefined
-  const results: WebhookDispatchResult[] = []
+  return mapWithConcurrency(
+    webhooks,
+    SLACK_WEBHOOK_DISPATCH_CONCURRENCY,
+    async ({ webhook: foundWebhook, workflow: foundWorkflow }) => {
+      const result = await dispatchResolvedWebhookTarget(
+        foundWebhook,
+        foundWorkflow,
+        body,
+        request,
+        {
+          requestId,
+          receivedAt,
+          triggerTimestampMs,
+        }
+      )
 
-  for (const { webhook: foundWebhook, workflow: foundWorkflow } of webhooks) {
-    const result = await dispatchResolvedWebhookTarget(foundWebhook, foundWorkflow, body, request, {
-      requestId,
-      receivedAt,
-      triggerTimestampMs,
-    })
+      if (result.outcome === 'ignored' && result.reason === 'filtered') {
+        const rawEvent = payload.event as Record<string, unknown> | undefined
+        const providerConfig = (foundWebhook.providerConfig as Record<string, unknown>) || {}
+        logger.info(
+          `[${requestId}] Event skipped by trigger filter for webhook ${foundWebhook.id}`,
+          {
+            eventKey: resolveSlackEventKey(payload),
+            configuredEvent: providerConfig.eventType,
+            channelType: rawEvent?.channel_type,
+            subtype: rawEvent?.subtype,
+            isThreadReply:
+              typeof rawEvent?.thread_ts === 'string' && rawEvent.thread_ts !== rawEvent.ts,
+            threadsSetting: providerConfig.threads,
+            botId: rawEvent?.bot_id,
+          }
+        )
+      }
 
-    if (result.outcome === 'ignored' && result.reason === 'filtered') {
-      const rawEvent = payload.event as Record<string, unknown> | undefined
-      const providerConfig = (foundWebhook.providerConfig as Record<string, unknown>) || {}
-      logger.info(`[${requestId}] Event skipped by trigger filter for webhook ${foundWebhook.id}`, {
-        eventKey: resolveSlackEventKey(payload),
-        configuredEvent: providerConfig.eventType,
-        channelType: rawEvent?.channel_type,
-        subtype: rawEvent?.subtype,
-        isThreadReply:
-          typeof rawEvent?.thread_ts === 'string' && rawEvent.thread_ts !== rawEvent.ts,
-        threadsSetting: providerConfig.threads,
-        botId: rawEvent?.bot_id,
-      })
+      return result
     }
-    results.push(result)
-  }
-
-  return results
+  )
 }

packages/db/scripts/migrate-slack-custom-bots.test.ts

@@ -261,6 +261,13 @@ describe('planLegacySlackTriggerLink', () => {
     ).toEqual({ updateTriggerBlock: true, webhookIdsToUpdate: ['webhook-1'] })
   })
 
+  it('links an undeployed trigger even when there is no webhook to mark', () => {
+    expect(planLegacySlackTriggerLink(triggerSource, existingCredential, [])).toEqual({
+      updateTriggerBlock: true,
+      webhookIdsToUpdate: [],
+    })
+  })
+
   it('is idempotent after the block and webhook are linked', () => {
     expect(
       planLegacySlackTriggerLink(