fix(slack-search): run turns inline and preserve OAuth callbacks

Author: TheodoreSpeaks

apps/sim/ee/credential-groups/components/slack-managed-users-access.test.tsx

@@ -1,5 +1,6 @@
 /** @vitest-environment jsdom */
 import { act } from 'react'
+import { toast } from '@sim/emcn'
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -44,6 +45,8 @@ describe('Slack member access selection', () => {
   let root: Root
   let container: HTMLDivElement
   let client: QueryClient
+  let channels: Array<{ onmessage: ((event: MessageEvent<unknown>) => void) | null }>
+  let popup: { location: { href: string }; closed: boolean; close: ReturnType<typeof vi.fn> }
   const bot: WorkspaceCredential = {
     id: '11111111-1111-4111-8111-111111111111',
     workspaceId: 'workspace-1',
@@ -62,6 +65,8 @@ describe('Slack member access selection', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
+    vi.spyOn(toast, 'error').mockReturnValue('toast')
+    vi.spyOn(toast, 'success').mockReturnValue('toast')
     vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true)
     mocks.create.mockResolvedValue(undefined)
     mocks.apps.mockReturnValue({
@@ -81,17 +86,23 @@ describe('Slack member access selection', () => {
       state: 'state',
       authorizationUrl: 'https://slack.com/oauth/v2/authorize',
     })
+    channels = []
     vi.stubGlobal(
       'BroadcastChannel',
       class {
+        onmessage: ((event: MessageEvent<unknown>) => void) | null = null
+        constructor() {
+          channels.push(this)
+        }
         close() {}
       }
     )
-    vi.spyOn(window, 'open').mockReturnValue({
+    popup = {
       location: { href: '' },
       closed: false,
       close: vi.fn(),
-    } as unknown as Window)
+    }
+    vi.spyOn(window, 'open').mockReturnValue(popup as unknown as Window)
     container = document.createElement('div')
     document.body.appendChild(container)
     root = createRoot(container)
@@ -103,6 +114,7 @@ describe('Slack member access selection', () => {
     client.clear()
     vi.restoreAllMocks()
     vi.unstubAllGlobals()
+    vi.useRealTimers()
   })
 
   async function render(
@@ -166,6 +178,118 @@ describe('Slack member access selection', () => {
     )
   }
 
+  async function completeAuthorization(state = 'state') {
+    await act(async () => {
+      for (const channel of channels) {
+        channel.onmessage?.(
+          new MessageEvent('message', {
+            data: {
+              type: 'slack-managed-users',
+              ok: true,
+              state,
+              credentialGroupId: 'group-1',
+              slackBotCredentialId: bot.id,
+            },
+          })
+        )
+      }
+    })
+  }
+
+  it('accepts authorization after browser isolation reports a live popup as closed', async () => {
+    vi.useFakeTimers()
+    await render()
+    await submit()
+    popup.closed = true
+    await act(async () => vi.advanceTimersByTimeAsync(1_000))
+
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(document.body.textContent).toContain('Waiting for Slack...')
+    await completeAuthorization('unrelated-state')
+    expect(toast.success).not.toHaveBeenCalled()
+    await completeAuthorization()
+    expect(toast.success).toHaveBeenCalledWith('Slack configured')
+    expect(mocks.onOpenChange).toHaveBeenCalledWith(false)
+    await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000))
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it('expires only after the authorization deadline and ignores a late callback', async () => {
+    vi.useFakeTimers()
+    await render()
+    await submit()
+    await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000 - 1))
+    expect(toast.error).not.toHaveBeenCalled()
+    await act(async () => vi.advanceTimersByTimeAsync(1))
+    expect(toast.error).toHaveBeenCalledExactlyOnceWith(
+      'Slack authorization expired. Please try again.'
+    )
+    expect(popup.close).toHaveBeenCalledOnce()
+    await completeAuthorization()
+    expect(toast.success).not.toHaveBeenCalled()
+  })
+
+  it('lets the user cancel an abandoned popup without reporting expiry', async () => {
+    vi.useFakeTimers()
+    await render()
+    await submit()
+    await clickButton('Cancel')
+    expect(popup.close).toHaveBeenCalledOnce()
+    expect(mocks.onOpenChange).toHaveBeenCalledWith(false)
+    await completeAuthorization()
+    await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000))
+    expect(toast.error).not.toHaveBeenCalled()
+    expect(toast.success).not.toHaveBeenCalled()
+  })
+
+  it('does not navigate or start a timeout when authorization startup finishes after cancel', async () => {
+    vi.useFakeTimers()
+    let finishStartup!: (value: { state: string; authorizationUrl: string }) => void
+    mocks.start.mockReturnValueOnce(
+      new Promise((resolve) => {
+        finishStartup = resolve
+      })
+    )
+    await render()
+    await submit()
+    await clickButton('Cancel')
+    await act(async () => {
+      finishStartup({ state: 'state', authorizationUrl: 'https://slack.com/oauth/v2/authorize' })
+    })
+    expect(popup.location.href).toBe('')
+    await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000))
+    expect(toast.error).not.toHaveBeenCalled()
+  })
+
+  it.each(['resolve', 'reject'] as const)(
+    'ignores authorization startup that completes with %s after unmount',
+    async (outcome) => {
+      vi.useFakeTimers()
+      let finishStartup!: () => void
+      mocks.start.mockReturnValueOnce(
+        new Promise((resolve, reject) => {
+          finishStartup = () =>
+            outcome === 'resolve'
+              ? resolve({
+                  state: 'state',
+                  authorizationUrl: 'https://slack.com/oauth/v2/authorize',
+                })
+              : reject(new Error('Authorization startup failed'))
+        })
+      )
+      await render()
+      await submit()
+      await act(async () => root.render(null))
+      await act(async () => finishStartup())
+
+      expect(popup.close).toHaveBeenCalledOnce()
+      expect(popup.location.href).toBe('')
+      await act(async () => vi.advanceTimersByTimeAsync(10 * 60 * 1_000))
+      expect(toast.error).not.toHaveBeenCalled()
+      expect(toast.success).not.toHaveBeenCalled()
+    }
+  )
+
   it('opens Slack app setup inline and returns to member setup when canceled', async () => {
     await render(undefined, [])
     expect(document.querySelector('a')).toBeNull()

apps/sim/ee/credential-groups/components/slack-managed-users-modal.tsx

@@ -108,7 +108,7 @@ export function SlackManagedUsersModal({
   const expectedState = useRef<string | null>(null)
   const expectedCredentialId = useRef<string | null>(null)
   const popup = useRef<Window | null>(null)
-  const popupWatcher = useRef<number | null>(null)
+  const authorizationTimeout = useRef<number | null>(null)
 
   const defaultCredentialId = initialCredentialId
     ? bots.some((bot) => bot.id === initialCredentialId)
@@ -141,8 +141,8 @@ export function SlackManagedUsersModal({
   const reset = () => {
     popup.current?.close()
     popup.current = null
-    if (popupWatcher.current !== null) window.clearInterval(popupWatcher.current)
-    popupWatcher.current = null
+    if (authorizationTimeout.current !== null) window.clearTimeout(authorizationTimeout.current)
+    authorizationTimeout.current = null
     expectedState.current = null
     expectedCredentialId.current = null
     setAppSetupOpen(false)
@@ -160,8 +160,8 @@ export function SlackManagedUsersModal({
     const verifiedCredentialId = expectedCredentialId.current
     expectedState.current = null
     expectedCredentialId.current = null
-    if (popupWatcher.current !== null) window.clearInterval(popupWatcher.current)
-    popupWatcher.current = null
+    if (authorizationTimeout.current !== null) window.clearTimeout(authorizationTimeout.current)
+    authorizationTimeout.current = null
     popup.current?.close()
     popup.current = null
     setPending(false)
@@ -222,14 +222,17 @@ export function SlackManagedUsersModal({
 
   useEffect(
     () => () => {
-      if (popupWatcher.current !== null) window.clearInterval(popupWatcher.current)
+      if (authorizationTimeout.current !== null) window.clearTimeout(authorizationTimeout.current)
       popup.current?.close()
+      popup.current = null
+      authorizationTimeout.current = null
+      expectedState.current = null
+      expectedCredentialId.current = null
     },
     []
   )
 
   const handleOpenChange = (nextOpen: boolean) => {
-    if (pending && !nextOpen) return
     onOpenChange(nextOpen)
     if (!nextOpen) reset()
   }
@@ -273,22 +276,22 @@ export function SlackManagedUsersModal({
           requiredScopes,
         },
       })
+      if (popup.current !== opened) return
       expectedState.current = result.state
       expectedCredentialId.current = selectedBot?.id ?? null
       opened.location.href = result.authorizationUrl
-      const startedAt = Date.now()
-      popupWatcher.current = window.setInterval(() => {
-        if (!opened.closed && Date.now() - startedAt < AUTHORIZATION_TIMEOUT_MS) return
-        window.clearInterval(popupWatcher.current ?? undefined)
-        popupWatcher.current = null
+      /** COOP can report a live OAuth popup as closed; only the deadline expires its state. */
+      authorizationTimeout.current = window.setTimeout(() => {
+        authorizationTimeout.current = null
         opened.close()
         popup.current = null
         expectedState.current = null
         expectedCredentialId.current = null
         setPending(false)
         toast.error('Slack authorization expired. Please try again.')
-      }, 500)
+      }, AUTHORIZATION_TIMEOUT_MS)
     } catch (authorizationError) {
+      if (popup.current !== opened) return
       opened.close()
       popup.current = null
       setPending(false)
@@ -318,15 +321,10 @@ export function SlackManagedUsersModal({
       <ChipModal
         open={open && !appSetupOpen}
         onOpenChange={handleOpenChange}
-        dismissDisabled={pending}
         srTitle={title}
         size='md'
       >
-        <ChipModalHeader
-          icon={SlackIcon}
-          onClose={() => handleOpenChange(false)}
-          closeDisabled={pending}
-        >
+        <ChipModalHeader icon={SlackIcon} onClose={() => handleOpenChange(false)}>
           {title}
         </ChipModalHeader>
         <ChipModalBody>
@@ -467,7 +465,6 @@ export function SlackManagedUsersModal({
         </ChipModalBody>
         <ChipModalFooter
           onCancel={() => handleOpenChange(false)}
-          cancelDisabled={pending}
           {...(needsApp
             ? {
                 primaryAction: {

apps/sim/lib/slack-search/README.md

@@ -144,6 +144,8 @@ existing conflicting active workspace bindings before applying the unique index.
    per thread. The three-minute execution deadline starts after a claim.
    Expired executions are marked failed and never replayed after an ambiguous
    external send. The shared outbox processor repairs missed wake-ups.
+   Wakes use the database-backed inline queue and run in the app process (ECS
+   on hosted deployments), even when other background jobs use Trigger.dev.
 4. `knowledge/application/slack-search/assistant.ts` resolves the sender’s email
    through that installation’s bot credential. It requires exactly one current,
    verified Sim member of the bound organization. Email never selects the

apps/sim/lib/slack-search/queue.test.ts

@@ -1,8 +1,11 @@
 /** @vitest-environment node */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const mocks = vi.hoisted(() => ({ enqueue: vi.fn(), run: vi.fn() }))
-vi.mock('@/lib/core/async-jobs', () => ({ getJobQueue: async () => ({ enqueue: mocks.enqueue }) }))
+const mocks = vi.hoisted(() => ({ enqueue: vi.fn(), run: vi.fn(), externalEnqueue: vi.fn() }))
+vi.mock('@/lib/core/async-jobs', () => ({
+  getInlineJobQueue: async () => ({ enqueue: mocks.enqueue }),
+  getJobQueue: async () => ({ enqueue: mocks.externalEnqueue }),
+}))
 vi.mock('@/lib/slack-search/handlers/search-message', () => ({
   handleSlackSearchMessage: mocks.run,
 }))
@@ -32,11 +35,12 @@ describe('Slack Search queue', () => {
       ])
     }
   })
-  it('supplies the same handler to the database runner', async () => {
+  it('runs in the app process even when the default queue has an external worker', async () => {
     const signal = new AbortController().signal
     await enqueueSlackSearch(job)
     await mocks.enqueue.mock.calls[0][2].runner(job, signal)
     expect(mocks.run).toHaveBeenCalledWith(job, signal)
+    expect(mocks.externalEnqueue).not.toHaveBeenCalled()
   })
   it('propagates enqueue failures so ingress can request a retry', async () => {
     mocks.enqueue.mockRejectedValueOnce(new Error('unavailable'))

apps/sim/lib/slack-search/queue.ts

@@ -1,13 +1,13 @@
 import { generateId } from '@sim/utils/id'
-import { getJobQueue } from '@/lib/core/async-jobs'
+import { getInlineJobQueue } from '@/lib/core/async-jobs'
 import {
   SLACK_SEARCH_CONCURRENCY,
   SLACK_SEARCH_MAX_DURATION_SECONDS,
 } from '@/lib/slack-search/constants'
 
-/** Wakes a durable turn; a repeated wake cannot repeat a claimed execution. */
+/** Runs durable turns in the app process; repeated wakes cannot repeat a claimed execution. */
 export async function enqueueSlackSearch(input: { turnId: string; installationId: string }) {
-  return (await getJobQueue()).enqueue(
+  return (await getInlineJobQueue()).enqueue(
     'slack-search',
     { turnId: input.turnId },
     {