fix(plane): correct tile styling and capped connector syncs (#8690)

* fix(plane): use a white integration background

* fix(plane): preserve distinct records in capped connector syncs

* fix(desktop): preserve legacy inbox timestamp precision

Author: waleedlatif1

apps/docs/content/docs/integrations/plane.mdx

@@ -7,7 +7,7 @@ import { BlockInfoCard } from "@/components/ui/block-info-card"
 
 <BlockInfoCard 
   type="plane"
-  color="#3F76FF"
+  color="#FFFFFF"
 />
 
 {/* MANUAL-CONTENT-START:intro */}

apps/sim/blocks/blocks/plane.ts

@@ -931,7 +931,7 @@ export const PlaneBlock: BlockConfig = {
   category: 'tools',
   integrationType: IntegrationType.Productivity,
   icon: PlaneIcon,
-  bgColor: '#3F76FF',
+  bgColor: '#FFFFFF',
   canvasPresentation: {
     defaultTitle: 'Plane',
     sentences: {

apps/sim/connectors/plane/plane.ts

@@ -111,6 +111,7 @@ export const planeConnector: ConnectorConfig = {
     }
     const response = await requestPlane(token, config, resourcePath(config), {
       cursor,
+      // Plane v1 cursor offsets depend on per_page, so it must stay fixed across pages.
       per_page: PAGE_SIZE,
       fields: config.contentType === 'pages' ? PAGE_FIELDS : WORK_ITEM_FIELDS,
       ...(config.contentType === 'work_items'
@@ -131,7 +132,9 @@ export const planeConnector: ConnectorConfig = {
     const total = fetched + documents.length
     if (syncContext) syncContext.totalDocsFetched = total
     const capped =
-      config.maxDocuments > 0 && total >= config.maxDocuments && page.nextCursor !== undefined
+      config.maxDocuments > 0 &&
+      total >= config.maxDocuments &&
+      (page.nextCursor !== undefined || page.results.length > remaining)
     if (capped && syncContext) syncContext.listingCapped = true
     logger.info('Listed Plane documents', {
       count: documents.length,

apps/sim/lib/desktop/application/executor.integration.ts

@@ -31,6 +31,7 @@ import {
 import { createDeferred } from '@sim/testing/helpers/deferred'
 import { featureFlagsMock, featureFlagsMockFns } from '@sim/testing/mocks/feature-flags.mock'
 import { generateId } from '@sim/utils/id'
+import { compareStrings } from '@sim/utils/string'
 import { eq, inArray, sql } from 'drizzle-orm'
 import { closeRedisConnection, getRedisClient } from '@/lib/core/config/redis'
 import type { DbTransaction } from '@/lib/db/types'
@@ -887,7 +888,7 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
       expect((await inbox(desktop)).items.map((item) => item.toolCallId)).toEqual(persisted)
     })
 
-    it('lists pending calls in persistence order even when their doorbell was never heard', async () => {
+    it('preserves legacy sub-millisecond order even when the doorbell was never heard', async () => {
       const desktop = await signedInDesktop()
       const run = await boundRun(desktop)
       const first = await pendingCall(run.runId, 'browser_navigate', { url: 'https://sim.ai' })
@@ -896,13 +897,24 @@ describe.runIf(Boolean(redisUrl))('desktop background executor protocol', () =>
         path: 'user-local/Project--mount-1',
         pattern: 'TODO',
       })
+      const persisted = [first, second, vfs].sort(compareStrings).reverse()
+      const createdAt = new Date(Date.now() - 1000).toISOString()
+      for (const [index, toolCallId] of persisted.entries()) {
+        await db
+          .update(copilotAsyncToolCalls)
+          .set({
+            persistSeq: null,
+            createdAt: sql`${createdAt}::timestamp + ${index} * interval '100 microseconds'`,
+          })
+          .where(eq(copilotAsyncToolCalls.toolCallId, toolCallId))
+      }
       await pendingCall(run.runId, 'run_workflow', {})
       /** Rung while no stream was open: nobody heard it. */
       ringDesktopInbox(desktop.deviceId, 'call')
 
       expect(
         (await inbox(desktop)).items.map((item) => item.kind === 'call' && item.toolCallId)
-      ).toEqual([first, second, vfs])
+      ).toEqual(persisted)
     })
 
     it('counts the device online after a pull or a stream open, and keeps it online when the stream closes', async () => {

apps/sim/lib/desktop/executor/repository.ts

@@ -89,22 +89,12 @@ const INBOX_ROW_LIMIT = 500
  * can share a millisecond, so the timestamp alone cannot order them. Rows persisted before the
  * sequence existed have none and come first, as they are the oldest.
  */
-const persistOrder = [
-  sql`${copilotAsyncToolCalls.persistSeq} ASC NULLS FIRST`,
-  asc(copilotAsyncToolCalls.createdAt),
-  asc(copilotAsyncToolCalls.toolCallId),
-]
-
-function comparePersistOrder(
-  a: { persistSeq: number | null; createdAt: Date; toolCallId: string },
-  b: { persistSeq: number | null; createdAt: Date; toolCallId: string }
-): number {
-  if (a.persistSeq !== b.persistSeq) {
-    if (a.persistSeq === null) return -1
-    if (b.persistSeq === null) return 1
-    return a.persistSeq - b.persistSeq
-  }
-  return a.createdAt.getTime() - b.createdAt.getTime() || a.toolCallId.localeCompare(b.toolCallId)
+function persistOrder() {
+  return [
+    sql`${copilotAsyncToolCalls.persistSeq} ASC NULLS FIRST`,
+    asc(copilotAsyncToolCalls.createdAt),
+    asc(copilotAsyncToolCalls.toolCallId),
+  ]
 }
 
 export interface DesktopDeviceRegistration {
@@ -232,27 +222,27 @@ export async function listDesktopInboxRows(identity: Omit<DesktopDeviceIdentity,
           state
         )
       )
-      .orderBy(...persistOrder)
+      .orderBy(...persistOrder())
       .limit(INBOX_ROW_LIMIT)
-  const [waiting, cancelled] = await Promise.all([
-    rowsWhere(
-      and(
-        eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
-        isNull(copilotAsyncToolCalls.executionOwnerToken),
-        or(sql`${copilotAsyncToolCalls.pickupDeadlineAt} > clock_timestamp()`, awaitingPermission),
-        inArray(copilotRuns.status, LIVE_RUN_STATUSES),
-        isNull(copilotRuns.toolAdmissionClosedAt)
-      )
-    ),
-    rowsWhere(
-      and(
-        isNotNull(copilotAsyncToolCalls.executionOwnerToken),
-        isNull(copilotAsyncToolCalls.executionSettledAt),
-        ne(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.running)
+  return rowsWhere(
+    and(
+      eq(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.pending),
+      isNull(copilotAsyncToolCalls.executionOwnerToken),
+      or(sql`${copilotAsyncToolCalls.pickupDeadlineAt} > clock_timestamp()`, awaitingPermission),
+      inArray(copilotRuns.status, LIVE_RUN_STATUSES),
+      isNull(copilotRuns.toolAdmissionClosedAt)
+    )
+  )
+    .unionAll(
+      rowsWhere(
+        and(
+          isNotNull(copilotAsyncToolCalls.executionOwnerToken),
+          isNull(copilotAsyncToolCalls.executionSettledAt),
+          ne(copilotAsyncToolCalls.status, ASYNC_TOOL_STATUS.running)
+        )
       )
-    ),
-  ])
-  return [...waiting, ...cancelled].sort(comparePersistOrder)
+    )
+    .orderBy(...persistOrder())
 }
 
 export type DesktopInboxRow = Awaited<ReturnType<typeof listDesktopInboxRows>>[number]
@@ -448,7 +438,7 @@ export async function listOverdueDesktopToolCalls(input: { slackMs: number; limi
         )
       )
     )
-    .orderBy(...persistOrder)
+    .orderBy(...persistOrder())
     .limit(input.limit)
   return rows.map((row) => row.toolCallId)
 }

apps/sim/scripts/test-plane-e2e.ts

@@ -600,7 +600,14 @@ try {
         (await planeConnector.validateConfig(apiKey, { ...config, maxDocuments: true })).valid,
         false
       )
-      const capped = await planeConnector.listDocuments(apiKey, { ...config, maxDocuments: 1 })
+      const cappedContext: Record<string, unknown> = { totalDocsFetched: 0 }
+      const capped = await planeConnector.listDocuments(
+        apiKey,
+        { ...config, maxDocuments: 1 },
+        undefined,
+        cappedContext
+      )
+      assert.equal(cappedContext.listingCapped, true)
       assert.equal(capped.documents.length, 1)
       assert.equal(capped.hasMore, false)
       assert.equal(capped.reconciliationSafe, false)
@@ -976,6 +983,55 @@ try {
       }
     })
   }
+  await check(
+    'v1: knowledge connector preserves distinct capped cursor continuations',
+    async () => {
+      const projectId = id(
+        (
+          await call('plane_create_project', 'v1', {
+            name: 'Disposable cursor verification',
+            identifier: `P${generateId().replaceAll('-', '').slice(0, 7).toUpperCase()}`,
+          })
+        ).result
+      )
+      const itemIds: string[] = []
+      for (let index = 0; index < 102; index++) {
+        itemIds.push(
+          id(
+            (
+              await call('plane_create_work_item', 'v1', {
+                project_id: projectId,
+                name: `Cursor verification ${index}`,
+              })
+            ).result
+          )
+        )
+      }
+      for (const maxDocuments of [101, 102]) {
+        const config = { workspaceSlug, projectId, baseUrl, maxDocuments }
+        const context: Record<string, unknown> = { totalDocsFetched: 0 }
+        const externalIds: string[] = []
+        let cursor: string | undefined
+        let hasMore = true
+        for (let page = 0; page < itemIds.length && hasMore; page++) {
+          const listing = await planeConnector.listDocuments(apiKey, config, cursor, context)
+          externalIds.push(...listing.documents.map((document) => document.externalId))
+          cursor = listing.nextCursor
+          hasMore = listing.hasMore
+          if (hasMore) assert(cursor, 'A continuing listing must provide its next cursor')
+        }
+        assert.equal(hasMore, false)
+        assert.equal(cursor, undefined)
+        assert.deepEqual(
+          externalIds,
+          itemIds.slice(0, maxDocuments).map((itemId) => `work_item:${itemId}`)
+        )
+        assert.equal(context.totalDocsFetched, maxDocuments)
+        if (maxDocuments < itemIds.length) assert.equal(context.listingCapped, true)
+        else assert.notEqual(context.listingCapped, true)
+      }
+    }
+  )
   if (!publicCallback)
     checks.push({
       name: 'Signed public webhook delivery',

apps/sim/tools/plane/coverage.json

@@ -779,7 +779,7 @@
       "checked": 102,
       "failures": 0
     },
-    "liveVerification": "Disposable-project HTTP checks exercise v2 and v1 compatibility on Plane Cloud. A real signed webhook delivery exercises registration, signature verification, filtering and cleanup. Community Edition is source-audited; no separate self-hosted server was live-tested.",
+    "liveVerification": "The recorded Plane Cloud validation covers v2 and v1 compatibility and a real signed webhook delivery. These Cloud checks precede the connector cap fixes and have not been rerun for this follow-up. Official Community Edition v1.4.2 was also tested over real HTTP with production Sim actions and the knowledge connector, reverse-proxy paths, signed attachment storage, actual Celery webhook deliveries, and capped cursor continuations without duplicate source records.",
     "liveResponses": {
       "checked": 145,
       "failures": 0
@@ -791,10 +791,32 @@
       "successfulV2Operations": 67,
       "successfulV1CompatibilityVariants": 56,
       "verifiedSignedDeliveries": 1
+    },
+    "communityChecks": {
+      "release": "v1.4.2",
+      "reference": "https://github.com/makeplane/plane/releases/tag/v1.4.2",
+      "passed": 23,
+      "failed": 0,
+      "skipped": 1,
+      "requests": 180,
+      "successfulV1Operations": 51,
+      "additionalReverseProxyChecksPassed": 8,
+      "verifiedSignedDeliveries": 354,
+      "webhookProcessingErrors": 0,
+      "cleanupVerified": true,
+      "boundary": "Production action transport and knowledge connector over real provider HTTP; actual provider webhook deliveries through the production handler. Full Sim route/workflow execution is covered separately by synthetic HTTP and database integration checks.",
+      "cursorPagination": {
+        "sourceWorkItems": 102,
+        "verifiedCaps": [101, 102],
+        "distinctSourceOrderPreserved": true,
+        "exactExhaustionNotMarkedCapped": true,
+        "independentGuardReversionsVerified": true
+      }
     }
   },
   "documentedLimitations": [
     "API availability depends on the Plane edition and version. Community Edition compatibility uses v1.",
+    "Community Edition v1.4.2 does not expose the public project pages API or the v2 webhook management API. Work-item knowledge sync and manual webhook subscriptions were verified against the real Community server.",
     "Signed object-storage transfers are performed with the returned upload URL and form fields; asset initialization and confirmation are exposed as Plane actions.",
     "Expanded v2 objects without a published nested schema are preserved as JSON rather than assigning guessed fields.",
     "The knowledge connector uses v1 to access description content, which v2 work-item reads omit. Offset listings disable automatic deletion reconciliation.",

packages/deployment-config/src/integration-metadata.ts

@@ -18175,7 +18175,7 @@
       "name": "Plane",
       "description": "Manage projects and work items in Plane",
       "longDescription": "Connect Plane Cloud or a self-hosted Plane instance. API v2 is the default; choose API v1 for Community Edition or older instances. Actions with a current successor are consolidated. Unsupported version-specific inputs fail explicitly. Manage work items, projects, cycles, modules, states, labels, comments, links, attachments, pages, and webhooks. API v1 compatibility is available within supported current actions.",
-      "bgColor": "#3F76FF",
+      "bgColor": "#FFFFFF",
       "iconName": "PlaneIcon",
       "docsUrl": "https://docs.sim.ai/integrations/plane",
       "operations": [