Merge remote-tracking branch 'origin/staging' into fix/dashboard-mention-resolve

# Conflicts:
#	apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
#	apps/sim/components/charts/time-series-chart.tsx
#	apps/sim/lib/dashboards/repository.integration.ts
#	apps/sim/lib/mothership/chat/display-message.ts

Author: waleedlatif1

.github/workflows/desktop-e2e.yml

@@ -17,6 +17,8 @@ on:
       - 'apps/sim/app/desktop/connect/**'
       - 'apps/sim/app/credential-groups/**'
       - 'apps/sim/hooks/queries/slack-search.ts'
+      - 'apps/sim/hooks/queries/personal-search-integrations.ts'
+      - 'apps/sim/hooks/use-search-integration-connection.ts'
       - 'apps/sim/hooks/use-github-installation-setup.ts'
       - 'apps/sim/app/o/**/integrations/indexed/use-member-enrollment.ts'
       - 'apps/sim/lib/api/contracts/desktop-source-connect.ts'

apps/desktop/e2e/source-connect.spec.ts

@@ -54,6 +54,11 @@ test('source authorization returns to its desktop screen and refreshes live', as
   const githubInventorySessions: string[] = []
   let nativeCredentialVisible = false
   let installed = false
+  let holdSlackStart = false
+  let canceledSlackRequests = 0
+  const personalAttempts = new Map<string, { session: string; completed: boolean }>()
+  let personalInventoryFailed = false
+  let personalInventoryFailures = 0
   let javascript = ''
   let stylesheet = ''
   let origin = ''
@@ -174,9 +179,83 @@ test('source authorization returns to its desktop screen and refreshes live', as
       const state = generateShortId(32)
       attempts.set(state, session)
       startSessions.push(session)
+      if (holdSlackStart) {
+        response.on('close', () => {
+          if (!response.writableEnded) canceledSlackRequests++
+        })
+        return
+      }
       json({ authorizationUrl: `${origin}/provider?state=${state}` })
       return
     }
+    if (path === '/api/knowledge/sim-search/personal-integrations') {
+      if (request.method === 'POST') {
+        const { oauthCompletionId } = await body()
+        personalAttempts.set(oauthCompletionId, { session, completed: false })
+        json({
+          success: true,
+          data: { url: `${origin}/personal-provider?completionId=${oauthCompletionId}` },
+        })
+      } else if (personalInventoryFailed) {
+        personalInventoryFailures++
+        json({ error: 'Inventory temporarily unavailable' }, 503)
+      } else {
+        const attempt = personalAttempts.get(url.searchParams.get('completionId') ?? '')
+        const connected = attempt?.completed === true
+        json({
+          success: true,
+          data: {
+            completedCredentialId: connected ? 'fixture-personal-account' : null,
+            connections: connected
+              ? [
+                  {
+                    name: 'Slack',
+                    providerId: 'slack',
+                    connectorType: 'slack',
+                    description: '',
+                    accounts: [
+                      {
+                        credentialId: 'fixture-personal-account',
+                        displayName: 'Fixture',
+                        status: 'connected',
+                        action: null,
+                      },
+                    ],
+                    connectionStatus: 'connected',
+                    action: null,
+                  },
+                ]
+              : [],
+            available: [
+              {
+                name: 'Slack',
+                description: '',
+                target: {
+                  type: 'link',
+                  provider: 'slack',
+                  connectorType: 'slack',
+                  connectionMode: 'live',
+                  optionId: 'fixture-option',
+                },
+              },
+            ],
+            nextCursor: null,
+          },
+        })
+      }
+      return
+    }
+    if (path === '/personal-callback') {
+      const completionId = url.searchParams.get('completionId') ?? ''
+      const attempt = personalAttempts.get(completionId)
+      if (!attempt || attempt.session !== session) {
+        json({ error: 'Wrong attempt' }, 403)
+        return
+      }
+      attempt.completed = true
+      redirect(`/credential-groups/complete?completionId=${completionId}`)
+      return
+    }
     if (path === '/api/knowledge/slack/oauth/callback') {
       const state = url.searchParams.get('state') ?? ''
       callbackSessions.push(session)
@@ -298,6 +377,12 @@ test('source authorization returns to its desktop screen and refreshes live', as
       )
       return
     }
+    if (path === '/personal-provider') {
+      response.end(
+        `<!doctype html><a href="/personal-callback?completionId=${url.searchParams.get('completionId')}">Authorize personal Search</a>`
+      )
+      return
+    }
     if (path === '/github-provider') {
       response.end(
         `<!doctype html><a href="/github-callback?setupId=${url.searchParams.get('setupId')}">Authorize GitHub</a>`
@@ -570,6 +655,68 @@ test('source authorization returns to its desktop screen and refreshes live', as
       await expect(web).toHaveURL(`${origin}/o/fixture-organization/integrations`)
       await expect(web.getByLabel('Account count')).toHaveText('1')
     })
+    await check('canceling Slack setup aborts the pending web HTTP request', async () => {
+      holdSlackStart = true
+      const starts = startSessions.length
+      try {
+        await web.getByRole('button', { name: 'Connect Slack', exact: true }).click()
+        await expect.poll(() => startSessions.length).toBe(starts + 1)
+        await web.getByRole('button', { name: 'Cancel Slack request', exact: true }).click()
+        await expect.poll(() => canceledSlackRequests).toBe(1)
+        await expect(web.getByRole('button', { name: 'Connect Slack', exact: true })).toBeEnabled()
+      } finally {
+        holdSlackStart = false
+      }
+    })
+    await check(
+      'desktop Search preserves pending receipts after inventory failure and allows cancellation/retry',
+      async () => {
+        const previousOpens = (await opened()).length
+        await page.getByRole('button', { name: 'Connect personal Search', exact: true }).click()
+        await expect.poll(async () => (await opened()).length).toBe(previousOpens + 1)
+        await external.goto((await opened())[previousOpens])
+        await external.getByRole('link', { name: 'Authorize personal Search' }).waitFor()
+        personalInventoryFailed = true
+        await external.getByRole('link', { name: 'Authorize personal Search' }).click()
+        await expect(external).toHaveURL(`${origin}/desktop/done?kind=connect`)
+        await expect.poll(() => personalInventoryFailures).toBeGreaterThan(0)
+        await expect(
+          page.getByRole('button', { name: 'Connect personal Search', exact: true })
+        ).toBeEnabled()
+        const receipt = () =>
+          page.evaluate(() => {
+            const entry = Object.entries(localStorage).find(([key]) =>
+              key.startsWith('sim.search-connection.')
+            )
+            if (!entry) return null
+            const attempt: { completionId: string; status: string; credentialId?: string } =
+              JSON.parse(entry[1])
+            return attempt
+          })
+        const pendingReceipt = await receipt()
+        expect(pendingReceipt).toMatchObject({ status: 'pending' })
+        await page.getByRole('button', { name: 'Connect personal Search', exact: true }).click()
+        expect(await receipt()).toEqual(pendingReceipt)
+        await page.getByRole('button', { name: 'Cancel personal Search', exact: true }).click()
+        await expect
+          .poll(receipt)
+          .toMatchObject({ completionId: pendingReceipt?.completionId, status: 'failed' })
+        personalInventoryFailed = false
+        await page.getByRole('button', { name: 'Retry personal inventory', exact: true }).click()
+        await page.getByRole('button', { name: 'Connect personal Search', exact: true }).click()
+        await expect.poll(async () => (await opened()).length).toBe(previousOpens + 2)
+        const retryReceipt = await receipt()
+        expect(retryReceipt).toMatchObject({ status: 'pending' })
+        expect(retryReceipt?.completionId).not.toBe(pendingReceipt?.completionId)
+        await external.goto((await opened())[previousOpens + 1])
+        await external.getByRole('link', { name: 'Authorize personal Search' }).click()
+        await expect.poll(receipt).toMatchObject({
+          completionId: retryReceipt?.completionId,
+          status: 'connected',
+          credentialId: 'fixture-personal-account',
+        })
+      }
+    )
     await page.screenshot({ path: test.info().outputPath('source-connect-desktop.png') })
   } finally {
     mkdirSync(dirname(reportPath), { recursive: true })

apps/sim/.env.example

@@ -269,5 +269,6 @@ CRON_SECRET=your_cron_secret # Use `openssl rand -hex 32` to generate. Authentic
 
 # Zoom member search: separate General OAuth app to preserve workflow grants.
 # Register ${NEXT_PUBLIC_APP_URL}/api/mcp/oauth/callback with the two meeting read scopes.
+# ZOOM_SEARCH=false           # Off-AppConfig fallback; set true to enable for eligible organization-owned scopes
 # ZOOM_MCP_CLIENT_ID=
 # ZOOM_MCP_CLIENT_SECRET=

apps/sim/app/api/billing/update-cost/route.test.ts

@@ -1040,32 +1040,38 @@ describe('POST /api/billing/update-cost — mid-run usage gate', () => {
       })
     })
 
-    it('never pauses a blocked payer with the usage card', async () => {
-      billingAttributionMockFns.mockCheckAccountBillingBlocks.mockResolvedValue({
-        blocked: true,
-        scope: 'payer',
+    it("offers the card for its admitted payer's plan, not the actor's current one", async () => {
+      billingCoreMockFns.mockGetOrganizationSubscription.mockResolvedValue({
+        id: 'sub-account-org',
+        referenceId: 'account-org',
+        plan: 'team',
+        status: 'active',
+        seats: 4,
+      })
+      billingPlanMockFns.mockGetHighestPrioritySubscription.mockResolvedValue({
+        id: 'sub-personal',
+        referenceId: 'user-1',
+        plan: 'pro',
+        status: 'active',
       })
 
       const body = await (await POST(directCallback())).json()
 
-      expect(body.usageExceeded).toBe(false)
+      expect(body.usageUpgrade).toMatchObject({
+        action: 'increase_limit',
+        message: expect.stringContaining("organization's usage limit"),
+      })
     })
 
-    it('keeps the exceeded verdict with the plan-upgrade card when the card read outlasts the callback budget', async () => {
-      billingPlanMockFns.mockGetHighestPrioritySubscription.mockImplementation(async () => {
-        await sleep(1500)
-        return { plan: 'pro' }
+    it('never pauses a blocked payer with the usage card', async () => {
+      billingAttributionMockFns.mockCheckAccountBillingBlocks.mockResolvedValue({
+        blocked: true,
+        scope: 'payer',
       })
-      const startedAt = Date.now()
 
       const body = await (await POST(directCallback())).json()
 
-      expect(body).toMatchObject({
-        success: true,
-        usageExceeded: true,
-        usageUpgrade: { action: 'upgrade_plan' },
-      })
-      expect(Date.now() - startedAt).toBeLessThan(1400)
+      expect(body.usageExceeded).toBe(false)
     })
   })
 

apps/sim/app/api/billing/update-cost/route.ts

@@ -86,7 +86,7 @@ function invalidBillingProtocolResponse(requestId: string, span: Span): NextResp
  * already recorded when this runs; a gate that cannot answer reports not-exceeded and leaves the
  * refusal to the next step or re-check rather than ending a paying run on a database blip,
  * and so does a verdict read that outlasts {@link USAGE_STANDING_TIMEOUT_MS}. An exceeded
- * verdict always pauses the run; a card read past that budget falls back to the plan-upgrade card.
+ * verdict always pauses the run.
  */
 async function readUsageStanding(
   userId: string,
@@ -99,10 +99,9 @@ async function readUsageStanding(
       ? () => readMidRunAccountUsageVerdict(accountDecision)
       : null
   if (!isHosted || !readVerdict) return { usageExceeded: false }
-  const deadlineAt = Date.now() + USAGE_STANDING_TIMEOUT_MS
   let verdict: MidRunUsageVerdict
   try {
-    verdict = await withinDeadline(readVerdict, deadlineAt)
+    verdict = await withinDeadline(readVerdict, Date.now() + USAGE_STANDING_TIMEOUT_MS)
   } catch {
     logger.warn('Usage standing read outlasted the callback budget; answering not exceeded')
     return { usageExceeded: false }
@@ -114,9 +113,8 @@ async function readUsageStanding(
     usageExceeded: true,
     usageUpgrade: await resolveUsageUpgradePayload(
       userId,
-      billingAttribution,
-      verdict.scope,
-      deadlineAt
+      billingAttribution ?? verdict.payer,
+      verdict.scope
     ),
   }
 }

apps/sim/app/api/copilot/api-keys/validate/route.test.ts

@@ -140,7 +140,10 @@ vi.mock('@/lib/workspaces/permissions/utils', () => permissionsMock)
 
 vi.mock('@/lib/workspaces/utils', () => workspacesUtilsMock)
 
-import { validateCopilotApiKeyBodySchema } from '@/lib/api/contracts/copilot'
+import {
+  validateCopilotApiKeyBodySchema,
+  validateCopilotApiKeyContract,
+} from '@/lib/api/contracts/copilot'
 import { resetMidRunUsageCaches } from '@/lib/billing/core/mid-run-usage'
 import { resetUsageGateCache } from '@/lib/billing/core/usage-gate-cache'
 import { POST } from '@/app/api/copilot/api-keys/validate/route'
@@ -248,6 +251,17 @@ describe('POST /api/copilot/api-keys/validate billing protocols', () => {
     expect(mockCheckServerSideUsageLimits).not.toHaveBeenCalled()
   })
 
+  it("sends a new turn's usage refusal as the empty 402 its contract declares", async () => {
+    mockCheckAttributedUsageLimits.mockResolvedValue({ isExceeded: true, scope: 'payer' })
+
+    const res = await POST(request(SELF_HOSTED_VALIDATE_BODY))
+
+    expect(res.status).toBe(402)
+    expect(await res.text()).toBe('')
+    const refusalSchema = validateCopilotApiKeyContract.response.statusSchemas?.[402]
+    expect(refusalSchema?.safeParse(undefined).success).toBe(true)
+  })
+
   it('preserves the actor member cap for markerless self-hosted admission', async () => {
     mockCheckAttributedUsageLimits.mockResolvedValue({
       isExceeded: true,
@@ -593,6 +607,28 @@ describe('validation lifecycle purposes', () => {
     })
   })
 
+  it("refuses a direct-v1 continuation with the card for its admitted payer's plan", async () => {
+    mockCheckUsageStatus.mockResolvedValue({ isExceeded: true, currentUsage: 12, limit: 10 })
+    mockGetOrganizationSubscription.mockResolvedValue({
+      id: 'sub-account-org',
+      referenceId: 'account-org',
+      plan: 'team',
+      status: 'active',
+      seats: 4,
+    })
+    mockGetHighestPrioritySubscription.mockResolvedValue(null)
+
+    const response = await POST(request(body, directHeaders))
+
+    expect(response.status).toBe(402)
+    await expect(response.json()).resolves.toMatchObject({
+      usageUpgrade: {
+        action: 'increase_limit',
+        message: expect.stringContaining("organization's usage limit"),
+      },
+    })
+  })
+
   it('admits a direct-v1 continuation whose usage cannot be read', async () => {
     mockCheckUsageStatus.mockResolvedValue({ isExceeded: true, unavailable: true })
     expect((await POST(request(body, directHeaders))).status).toBe(200)

apps/sim/app/api/copilot/api-keys/validate/route.ts

@@ -453,7 +453,7 @@ export const POST = withRouteHandler((req: NextRequest) =>
             span.setAttribute(TraceAttr.HttpStatusCode, 402)
             const usageUpgrade = await resolveUsageUpgradePayload(
               userId,
-              billing?.kind === 'attributed' ? billing.attribution : undefined,
+              billing?.kind === 'attributed' ? billing.attribution : verdict.payer,
               verdict.scope
             )
             return NextResponse.json<ValidateCopilotApiKeyUsageExceeded>(

apps/sim/app/api/credential-groups/slack-managed-users/callback/route.test.ts

@@ -0,0 +1,18 @@
+import { authMockFns } from '@sim/testing/mocks/auth.mock'
+import { createMockRequest } from '@sim/testing/mocks/request.mock'
+import { expect, it } from 'vitest'
+import { GET } from '@/app/api/credential-groups/slack-managed-users/callback/route'
+
+it('preserves sign-in recovery when the managed Slack callback loses its session', async () => {
+  authMockFns.mockGetSession.mockResolvedValueOnce(null)
+  const response = await GET(
+    createMockRequest({
+      url: 'http://localhost/api/credential-groups/slack-managed-users/callback?state=fixture-state&code=fixture-code',
+    })
+  )
+  expect(response.status).toBe(303)
+  const location = new URL(response.headers.get('location')!)
+  expect(location.pathname).toBe('/credential-groups/slack-complete')
+  expect(location.searchParams.get('state')).toBe('fixture-state')
+  expect(location.searchParams.get('reason')).toBe('signin_required')
+})

apps/sim/app/api/credential-groups/slack-managed-users/callback/route.ts

@@ -41,7 +41,7 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
       ok: false,
       message: 'Sign in to Sim to complete this Slack setup.',
       state: rawState,
-      reason: 'unauthenticated',
+      reason: 'signin_required',
     })
   }
   const parsed = await parseRequest(slackCredentialGroupConfigurationCallbackContract, request, {})