fix(knowledge): raise the connector sync ceiling and tie it to the stale lock

A 2,600-document library exhausted the 30-minute budget and the run was killed
mid-listing, leaving the connector's `syncing` lock set until the scheduler
reclaimed it.

Raising the ceiling is not a lone constant, because reclaiming a stale lock
flips the connector to `error` and frees it for another sync. A TTL at or below
the run ceiling would hand the lock to a successor while the first sync is still
writing — two syncs racing the same `(connectorId, externalId)` rows. The
previous values, a 1800s run against a hard-coded 120-minute TTL declared in a
different file, held that invariant only by coincidence.

Both now derive from one another, with a test pinning the margin so the next
raise cannot silently break it.

Author: waleedlatif1

apps/sim/app/api/knowledge/connectors/sync/route.ts

@@ -9,6 +9,7 @@ import { mapWithConcurrency } from '@/lib/core/utils/concurrency'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { dispatchSync } from '@/lib/knowledge/connectors/queue'
+import { CONNECTOR_SYNC_STALE_LOCK_TTL_MS } from '@/lib/knowledge/connectors/sync-limits'
 
 export const dynamic = 'force-dynamic'
 
@@ -39,8 +40,7 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
   try {
     const now = new Date()
 
-    const STALE_SYNC_TTL_MS = 120 * 60 * 1000
-    const staleCutoff = new Date(now.getTime() - STALE_SYNC_TTL_MS)
+    const staleCutoff = new Date(now.getTime() - CONNECTOR_SYNC_STALE_LOCK_TTL_MS)
 
     const recoveredConnectors = await db
       .update(knowledgeConnector)

apps/sim/background/knowledge-connector-sync.ts

@@ -5,6 +5,7 @@ import {
   type ConnectorSyncPayload,
 } from '@/lib/knowledge/connectors/queue'
 import { executeSync } from '@/lib/knowledge/connectors/sync-engine'
+import { CONNECTOR_SYNC_MAX_DURATION_SECONDS } from '@/lib/knowledge/connectors/sync-limits'
 
 const logger = createLogger('TriggerKnowledgeConnectorSync')
 
@@ -39,7 +40,7 @@ export async function executeConnectorSyncJob(payload: unknown) {
 
 export const knowledgeConnectorSync = task({
   id: 'knowledge-connector-sync',
-  maxDuration: 1800,
+  maxDuration: CONNECTOR_SYNC_MAX_DURATION_SECONDS,
   machine: 'large-2x',
   retry: {
     maxAttempts: 3,

apps/sim/lib/knowledge/connectors/sync-limits.test.ts

@@ -0,0 +1,26 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  CONNECTOR_SYNC_MAX_DURATION_SECONDS,
+  CONNECTOR_SYNC_STALE_LOCK_TTL_MS,
+} from '@/lib/knowledge/connectors/sync-limits'
+
+describe('connector sync limits', () => {
+  /**
+   * Reclaiming a stale lock frees it for another sync, so a TTL at or below the
+   * run ceiling would start a second sync while the first is still writing. This
+   * guards the invariant against a future hard-coded TTL, not the derivation.
+   */
+  it('keeps at least a 2x margin between the run ceiling and the reclaim', () => {
+    expect(CONNECTOR_SYNC_STALE_LOCK_TTL_MS).toBeGreaterThanOrEqual(
+      CONNECTOR_SYNC_MAX_DURATION_SECONDS * 2 * 1000
+    )
+  })
+
+  /** A 2,600-document library exhausted the previous 1800s budget mid-listing. */
+  it('allows a run longer than the half hour that timed out in production', () => {
+    expect(CONNECTOR_SYNC_MAX_DURATION_SECONDS).toBeGreaterThan(1800)
+  })
+})

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

@@ -0,0 +1,16 @@
+/**
+ * Wall-clock ceiling for a single connector sync run. A large document library
+ * needs more than the half hour this used to allow: a 2,600-document site
+ * exhausted the old budget and was killed mid-listing, leaving its `syncing`
+ * lock set until the scheduler reclaimed it.
+ */
+export const CONNECTOR_SYNC_MAX_DURATION_SECONDS = 3600
+
+/**
+ * How long a connector may sit in `syncing` before the scheduler reclaims its lock.
+ *
+ * MUST stay above {@link CONNECTOR_SYNC_MAX_DURATION_SECONDS}: reclaiming frees the
+ * lock for another sync, so a TTL at or below the run ceiling would start a second
+ * sync while the first is still writing, both racing the same documents.
+ */
+export const CONNECTOR_SYNC_STALE_LOCK_TTL_MS = CONNECTOR_SYNC_MAX_DURATION_SECONDS * 2 * 1000