fix(connectors): blogpost labels and capped listing deletion reconciliation

- Confluence: fetchLabelsForPages now tries both /pages/{id}/labels and
  /blogposts/{id}/labels, preventing label loss when getDocument hydrates
  blogpost content (previously returned empty labels on 404).
- Sync engine: skip deletion reconciliation when listing was capped
  (maxFiles/maxThreads). Connectors signal this via syncContext.listingCapped.
  Prevents incorrect deletion of docs beyond the cap that still exist in source.
  fullSync override still forces deletion for explicit cleanup.
- Google Drive & Gmail: set syncContext.listingCapped = true when cap is hit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/connectors/confluence/confluence.ts

@@ -31,23 +31,34 @@ async function fetchLabelsForPages(
     const results = await Promise.all(
       batch.map(async (pageId) => {
         try {
-          const url = `https://api.atlassian.com/ex/confluence/${cloudId}/wiki/api/v2/pages/${pageId}/labels`
-          const response = await fetchWithRetry(url, {
-            method: 'GET',
-            headers: {
-              Accept: 'application/json',
-              Authorization: `Bearer ${accessToken}`,
-            },
-          })
+          let data: Record<string, unknown> | null = null
+          for (const contentType of ['pages', 'blogposts']) {
+            const url = `https://api.atlassian.com/ex/confluence/${cloudId}/wiki/api/v2/${contentType}/${pageId}/labels`
+            const response = await fetchWithRetry(url, {
+              method: 'GET',
+              headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+              },
+            })
+
+            if (response.ok) {
+              data = await response.json()
+              break
+            }
+            if (response.status !== 404) {
+              logger.warn(`Failed to fetch labels for ${contentType} ${pageId}`, {
+                status: response.status,
+              })
+            }
+          }
 
-          if (!response.ok) {
-            logger.warn(`Failed to fetch labels for page ${pageId}`, { status: response.status })
+          if (!data) {
             return { pageId, labels: [] as string[] }
           }
 
-          const data = await response.json()
-          const labels = (data.results || []).map(
-            (label: Record<string, unknown>) => label.name as string
+          const labels = ((data.results as Record<string, unknown>[]) || []).map(
+            (label) => label.name as string
           )
           return { pageId, labels }
         } catch (error) {

apps/sim/connectors/gmail/gmail.ts

@@ -454,6 +454,7 @@ export const gmailConnector: ConnectorConfig = {
 
     const nextPageToken = data.nextPageToken as string | undefined
     const hitLimit = newTotal >= maxThreads
+    if (hitLimit && syncContext) syncContext.listingCapped = true
 
     return {
       documents,

apps/sim/connectors/google-drive/google-drive.ts

@@ -274,6 +274,7 @@ export const googleDriveConnector: ConnectorConfig = {
     const totalFetched = previouslyFetched + documents.length
     if (syncContext) syncContext.totalDocsFetched = totalFetched
     const hitLimit = maxFiles > 0 && totalFetched >= maxFiles
+    if (hitLimit && syncContext) syncContext.listingCapped = true
 
     const nextPageToken = data.nextPageToken as string | undefined
 

apps/sim/lib/knowledge/connectors/sync-engine.ts

@@ -554,9 +554,9 @@ export async function executeSync(
       }
     }
 
-    // Reconcile deletions for non-incremental syncs (which return ALL docs).
-    // Skip for incremental syncs since results only contain changed docs.
-    if (!isIncremental) {
+    // Reconcile deletions for non-incremental syncs that returned ALL docs.
+    // Skip when listing was capped (maxFiles/maxThreads) — unseen docs may still exist in the source.
+    if (!isIncremental && (!syncContext?.listingCapped || options?.fullSync)) {
       const removedIds = existingDocs
         .filter((d) => d.externalId && !seenExternalIds.has(d.externalId))
         .map((d) => d.id)