fix(connectors): keep per-member listings complete across partial scopes and blank caps

Teams, SharePoint, and OneDrive skip one of several channels or a descendant
folder a member cannot reach instead of failing the whole listing, which the
members-mode crawl would read as the member reaching nothing. Gmail and
Outlook keep their default cap for a null, empty, or whitespace field rather
than lifting it, through a shared parseDefaultedUnlimitedSafeInteger. The
Confluence incremental CQL clause is fixed on the first page so a cursor is
never paired with a query that crossed a minute boundary.

Author: waleedlatif1

apps/sim/connectors/confluence/confluence.test.ts

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment node
  */
-import { describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   AtlassianSiteNotAccessibleError,
   AtlassianSiteNotMatchedError,
@@ -408,3 +408,66 @@ describe('preserveConfluenceCallouts', () => {
     expect(result).toContain('[WARNING] Do NOT use this form for: GitLab')
   })
 })
+
+describe('confluence incremental CQL listing', () => {
+  const fetchMock =
+    vi.fn<(input: string | URL | Request, init?: RequestInit) => Promise<Response>>()
+
+  function jsonResponse(body: unknown): Response {
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    })
+  }
+
+  function cqlOfCall(index: number): string | null {
+    return new URL(String(fetchMock.mock.calls[index][0])).searchParams.get('cql')
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    fetchMock.mockReset()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.useRealTimers()
+  })
+
+  it('keeps one lastModified clause across pages that straddle a minute boundary', async () => {
+    const lastSyncAt = new Date('2026-09-01T11:30:00Z')
+    const config = { domain: 'example.atlassian.net', spaceKey: 'ENG' }
+    const syncContext: Record<string, unknown> = { cloudId: 'cloud-1' }
+    fetchMock
+      .mockResolvedValueOnce(
+        jsonResponse({
+          results: [],
+          _links: { next: '/wiki/rest/api/content/search?cursor=page-2&cql=ignored' },
+        })
+      )
+      .mockResolvedValueOnce(jsonResponse({ results: [] }))
+
+    vi.setSystemTime(new Date('2026-09-01T12:00:59Z'))
+    const first = await confluenceConnector.listDocuments(
+      'token',
+      config,
+      undefined,
+      syncContext,
+      lastSyncAt
+    )
+    expect(first.nextCursor).toBe('page-2')
+
+    vi.setSystemTime(new Date('2026-09-01T12:01:01Z'))
+    await confluenceConnector.listDocuments(
+      'token',
+      config,
+      first.nextCursor,
+      syncContext,
+      lastSyncAt
+    )
+
+    expect(cqlOfCall(0)).toContain('lastModified >= now("-31m")')
+    expect(cqlOfCall(1)).toBe(cqlOfCall(0))
+  })
+})

apps/sim/connectors/confluence/confluence.ts

@@ -698,6 +698,23 @@ export function buildLastModifiedClause(lastSyncAt: Date, now: Date): string {
   return `lastModified >= now("-${minutes}m")`
 }
 
+/**
+ * The `lastModified` clause every page of one listing shares. The clause is a
+ * window relative to the server clock, so recomputing it on a later page that
+ * crosses a minute boundary would pair the cursor `_links.next` issued with a
+ * query it was not issued for; the first page fixes it for the run.
+ */
+export function resolveLastModifiedClause(
+  lastSyncAt: Date,
+  syncContext: Record<string, unknown> | undefined
+): string {
+  const fixed = syncContext?.cqlLastModifiedClause
+  if (typeof fixed === 'string') return fixed
+  const clause = buildLastModifiedClause(lastSyncAt, new Date())
+  if (syncContext) syncContext.cqlLastModifiedClause = clause
+  return clause
+}
+
 /**
  * Page size for CQL search. The endpoint defaults to 25 and documents no hard
  * maximum, so this stays conservatively below the fixed system limits it warns
@@ -749,7 +766,7 @@ async function listDocumentsViaCql(
     cql += ` AND label in (${labelList})`
   }
 
-  if (lastSyncAt) cql += ` AND ${buildLastModifiedClause(lastSyncAt, new Date())}`
+  if (lastSyncAt) cql += ` AND ${resolveLastModifiedClause(lastSyncAt, syncContext)}`
 
   const fetchedSoFar = (syncContext?.totalDocsFetched as number) ?? 0
   const remaining = maxPages > 0 ? maxPages - fetchedSoFar : Number.POSITIVE_INFINITY

apps/sim/connectors/gmail/gmail.test.ts

@@ -12,6 +12,7 @@ vi.mock('@/lib/knowledge/documents/utils', () => ({
 vi.mock('@/components/icons', () => ({ GmailIcon: () => null }))
 
 import { gmailConnector } from '@/connectors/gmail/gmail'
+import { DEFAULT_MAX_THREADS } from '@/connectors/gmail/meta'
 
 function threads(count: number, prefix: string) {
   return Array.from({ length: count }, (_, i) => ({ id: `${prefix}-${i}`, historyId: '1' }))
@@ -86,3 +87,20 @@ describe('gmail listDocuments with maxThreads 0 (unlimited, a per-member sync)',
     expect(syncContext.listingCapped).toBe(true)
   })
 })
+
+describe('gmail listDocuments with a blank maxThreads', () => {
+  it.each([null, '', '   '])('keeps the default cap for %j', async (maxThreads) => {
+    mockPages([])
+    const syncContext: Record<string, unknown> = { totalThreadsFetched: DEFAULT_MAX_THREADS }
+
+    const result = await gmailConnector.listDocuments(
+      'token',
+      { maxThreads },
+      undefined,
+      syncContext
+    )
+
+    expect(result.hasMore).toBe(false)
+    expect(mockFetchWithRetry).not.toHaveBeenCalled()
+  })
+})

apps/sim/connectors/gmail/gmail.ts

@@ -6,8 +6,8 @@ import type { ConnectorConfig, ExternalDocument, ExternalDocumentList } from '@/
 import {
   htmlToPlainText,
   joinTagArray,
+  parseDefaultedUnlimitedSafeInteger,
   parseMultiValue,
-  parseOptionalUnlimitedSafeInteger,
   parseTagDate,
 } from '@/connectors/utils'
 
@@ -452,14 +452,12 @@ export const gmailConnector: ConnectorConfig = {
       labelIndex = resolved
     }
     const searchQuery = buildSearchQuery(sourceConfig, labelIndex)
-    /** Absent means the default cap; an explicit 0 (a per-member sync) means unlimited. */
-    const maxThreads =
-      sourceConfig.maxThreads === undefined
-        ? DEFAULT_MAX_THREADS
-        : parseOptionalUnlimitedSafeInteger(
-            sourceConfig.maxThreads,
-            'maxThreads must be a non-negative integer'
-          )
+    /** A blank field keeps the default cap; an explicit 0 (a per-member sync) means unlimited. */
+    const maxThreads = parseDefaultedUnlimitedSafeInteger(
+      sourceConfig.maxThreads,
+      DEFAULT_MAX_THREADS,
+      'maxThreads must be a non-negative integer'
+    )
 
     const totalFetched = (syncContext?.totalThreadsFetched as number) ?? 0
     if (maxThreads > 0 && totalFetched >= maxThreads) {

apps/sim/connectors/microsoft-excel/meta.ts

@@ -14,7 +14,11 @@ export const microsoftExcelConnectorMeta: ConnectorMeta = {
     requiredScopes: ['Files.ReadWrite'],
   },
 
-  /** Every worksheet of the one workbook is listed; nothing caps the listing. */
+  /**
+   * No config field caps the listing: every worksheet of the one workbook is
+   * listed. The `MAX_WORKSHEETS` memory bound flags `listingCapped` when it
+   * bites, which the members-mode crawl reads as an incomplete listing.
+   */
   permissionScopedListing: { capFieldIds: [] },
   configFields: [
     {

apps/sim/connectors/microsoft-teams/microsoft-teams.test.ts

@@ -12,6 +12,7 @@ vi.mock('@/lib/knowledge/documents/utils', () => ({
 vi.mock('@/components/icons', () => ({ MicrosoftTeamsIcon: () => null }))
 
 import { microsoftTeamsConnector } from '@/connectors/microsoft-teams/microsoft-teams'
+import { PER_MEMBER_LISTING_CONTEXT } from '@/connectors/utils'
 
 const GRAPH = 'https://graph.microsoft.com/v1.0'
 const TEAM_ID = 'team-1'
@@ -80,3 +81,76 @@ describe('microsoft teams listing scope', () => {
     expect(microsoftTeamsConnector.isListingScopeUnavailableError!(error)).toBe(false)
   })
 })
+
+describe('microsoft teams per-member listing of several channels', () => {
+  const messagesUrl = (channelId: string) =>
+    `${GRAPH}/teams/${TEAM_ID}/channels/${channelId}/messages?$top=50&$expand=replies`
+
+  function teamsMessage(id: string) {
+    return {
+      id,
+      messageType: 'message',
+      createdDateTime: '2026-01-01T00:00:00Z',
+      from: { user: { id: 'u1', displayName: 'Ada' } },
+      body: { contentType: 'text', content: `hello from ${id}` },
+    }
+  }
+
+  /** General is readable, Private answers 403 on its messages, Secret is not listed at all. */
+  function mockChannels() {
+    mockGraph({
+      [CHANNELS_URL]: {
+        body: {
+          value: [
+            { id: 'c1', displayName: 'General' },
+            { id: 'c2', displayName: 'Private' },
+          ],
+        },
+      },
+      [messagesUrl('c1')]: { body: { value: [teamsMessage('m1')] } },
+      [messagesUrl('c2')]: { status: 403, body: {} },
+    })
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('skips the channels the member cannot reach and keeps the rest', async () => {
+    mockChannels()
+
+    const result = await microsoftTeamsConnector.listDocuments(
+      'token',
+      { teamId: TEAM_ID, channel: ['General', 'Private', 'Secret'] },
+      undefined,
+      { ...PER_MEMBER_LISTING_CONTEXT }
+    )
+
+    expect(result.documents.map((doc) => doc.externalId)).toEqual(['c1'])
+    expect(result.hasMore).toBe(false)
+  })
+
+  it('still fails a shared listing when one of several channels is unreachable', async () => {
+    mockChannels()
+
+    const error = await microsoftTeamsConnector
+      .listDocuments('token', { teamId: TEAM_ID, channel: ['General', 'Private'] }, undefined, {})
+      .catch((e: unknown) => e)
+
+    expect(error).toBeInstanceOf(Error)
+    expect(microsoftTeamsConnector.isListingScopeUnavailableError!(error)).toBe(true)
+  })
+
+  it('reads a sole unreachable channel as the whole scope', async () => {
+    mockChannels()
+
+    const error = await microsoftTeamsConnector
+      .listDocuments('token', { teamId: TEAM_ID, channel: 'Private' }, undefined, {
+        ...PER_MEMBER_LISTING_CONTEXT,
+      })
+      .catch((e: unknown) => e)
+
+    expect(error).toBeInstanceOf(Error)
+    expect(microsoftTeamsConnector.isListingScopeUnavailableError!(error)).toBe(true)
+  })
+})