fix(connectors): revert pages drain, restore CloudWatch labels, tighten key lookup

Six adversarial verification passes against the provider spec and the surrounding
plumbing found three defects in the prior commits.

Reverts the Confluence pages selector to a single request. Draining it was not
strictly better: with no search term `title` is unset, so opening the dropdown
walked the entire site — up to 50 sequential requests and 2,500 options where
there had been one request and 50 — and the route forwards no abort signal
upstream, so superseded drains still bill the tenant's rate limit. The same
fan-out reached `loadAllSelectorOptions`, and the justification rested on `title`
semantics Atlassian does not publish. The list cap is a real gap, but it needs
confirmed server-side search, not brute force. Keeps the `results` guard.

Restores selector display names for CloudWatch blocks. Narrowing a caller's
`enabled` against `definition.enabled` disabled a detail query those selectors
satisfy without AWS context, so collapsed blocks rendered "-" instead of the log
group name. A caller that opts in is now narrowed only by the hard precondition
that `fetchById` exists, which is what `queryFn` actually asserts.

Queries both space statuses concurrently rather than sequentially: the key is
user-typed text, so a miss dominates while typing and paid two round-trips. Each
row now falls back to the status its own call requested.

Also drops the "enter the value directly" empty states — the combobox is not
editable, so there is no such affordance — and dedupes `onSearchChange`, which
several reset paths fire redundantly.

Author: waleedlatif1

apps/sim/app/api/tools/confluence/pages/route.ts

@@ -23,7 +23,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
     const parsed = await parseRequest(confluencePagesSelectorContract, request, {})
     if (!parsed.success) return parsed.response
 
-    const { domain, accessToken, title, cloudId: providedCloudId, limit, cursor } = parsed.data.body
+    const { domain, accessToken, title, cloudId: providedCloudId, limit } = parsed.data.body
 
     const cloudId = providedCloudId || (await getConfluenceCloudId(domain, accessToken))
 
@@ -43,10 +43,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       queryParams.append('title', title)
     }
 
-    if (cursor) {
-      queryParams.append('cursor', cursor)
-    }
-
     const queryString = queryParams.toString()
     const url = queryString ? `${baseUrl}?${queryString}` : baseUrl
 
@@ -86,24 +82,8 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       }
     }
 
-    /**
-     * Confluence paginates with an opaque cursor carried in `_links.next`. Reading
-     * it is what lets the selector continue past the first page — without it the
-     * dropdown silently showed only `limit` pages of however many exist.
-     */
-    let nextCursor: string | undefined
-    const nextLink = data._links?.next as string | undefined
-    if (nextLink) {
-      try {
-        nextCursor =
-          new URL(nextLink, 'https://placeholder').searchParams.get('cursor') || undefined
-      } catch {
-        nextCursor = undefined
-      }
-    }
-
     return NextResponse.json({
-      files: (data.results || []).map((page: any) => ({
+      files: data.results.map((page: any) => ({
         id: page.id,
         name: page.title,
         mimeType: 'confluence/page',
@@ -112,7 +92,6 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
         spaceId: page.spaceId,
         webViewLink: page._links?.webui || '',
       })),
-      nextCursor,
     })
   } catch (error) {
     logger.error('Error fetching Confluence pages:', error)

apps/sim/app/api/tools/confluence/selector-spaces/route.ts

@@ -23,6 +23,27 @@ const PAGE_LIMIT = 250
 
 type SpaceStatus = 'current' | 'archived'
 
+/** A row as Confluence returns it. `status` is not marked required in the v2 schema. */
+interface SpaceRow {
+  id: string
+  name: string
+  key: string
+  status?: SpaceStatus
+}
+
+interface SpacesResponse {
+  results?: SpaceRow[]
+  _links?: { next?: string }
+}
+
+/** A row as this selector emits it, with `status` always resolved. */
+interface SelectorSpace {
+  id: string
+  name: string
+  key: string
+  status: SpaceStatus
+}
+
 /**
  * Cursor format: `<status>:<innerCursor>`. Empty inner cursor means "first page
  * of that status". When current is exhausted we hand back `archived:` so the
@@ -103,7 +124,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
 
     const requestSpaces = async (
       search: URLSearchParams
-    ): Promise<{ ok: true; data: any } | { ok: false; response: NextResponse }> => {
+    ): Promise<{ ok: true; data: SpacesResponse } | { ok: false; response: NextResponse }> => {
       const response = await fetch(`${baseUrl}?${search.toString()}`, {
         method: 'GET',
         headers: { Accept: 'application/json', Authorization: `Bearer ${accessToken}` },
@@ -119,46 +140,54 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       return { ok: true, data: await response.json() }
     }
 
-    let data: any
+    const toSpaces = (rows: SpaceRow[] | undefined, queried: SpaceStatus): SelectorSpace[] =>
+      (rows ?? []).map((space) => ({
+        id: space.id,
+        name: space.name,
+        key: space.key,
+        // Trust the row's own status; fall back to the status this call asked for.
+        status: space.status ?? queried,
+      }))
+
     if (spaceKey) {
       /**
        * Exact-key lookup, bypassing the paged drain the dropdown otherwise depends
-       * on. `status` is queried explicitly per value rather than omitted: it takes a
-       * single value on this endpoint (unlike `/pages`, where it is an array with a
-       * documented `current,archived` default), and no default is documented for
-       * `/spaces`. Archived spaces are reachable in the paged path and sync works
-       * against them, so resolving only `current` would silently miss them.
+       * on. Both statuses are queried explicitly rather than omitting `status`: it
+       * takes a single value on this endpoint (unlike `/pages`, where it is an array
+       * with a documented `current,archived` default) and `/spaces` documents no
+       * default, while archived spaces are reachable in the paged path and sync works
+       * against them. Concurrent because the key is user-typed text, so a miss — which
+       * dominates while typing — would otherwise pay two round-trips.
        */
-      let result = await requestSpaces(
-        new URLSearchParams({ keys: spaceKey, limit: String(PAGE_LIMIT), status: 'current' })
-      )
-      if (!result.ok) return result.response
-      if (!result.data.results?.length) {
-        result = await requestSpaces(
+      const [current, archived] = await Promise.all([
+        requestSpaces(
+          new URLSearchParams({ keys: spaceKey, limit: String(PAGE_LIMIT), status: 'current' })
+        ),
+        requestSpaces(
           new URLSearchParams({ keys: spaceKey, limit: String(PAGE_LIMIT), status: 'archived' })
-        )
-        if (!result.ok) return result.response
-      }
-      data = result.data
-    } else {
-      const params = new URLSearchParams({ limit: String(PAGE_LIMIT), status })
-      if (inner) params.set('cursor', inner)
-      const result = await requestSpaces(params)
-      if (!result.ok) return result.response
-      data = result.data
-    }
-    const spaces = (data.results || []).map(
-      (space: { id: string; name: string; key: string; status?: SpaceStatus }) => ({
-        id: space.id,
-        name: space.name,
-        key: space.key,
-        // An exact-key lookup is not scoped to one status, so trust the row's own.
-        status: space.status ?? status,
+        ),
+      ])
+      if (!current.ok) return current.response
+      if (!archived.ok) return archived.response
+
+      // A single resolution, never a page in a drained stream, so no cursor.
+      return NextResponse.json({
+        spaces: [
+          ...toSpaces(current.data.results, 'current'),
+          ...toSpaces(archived.data.results, 'archived'),
+        ],
+        nextCursor: undefined,
       })
-    )
+    }
+
+    const params = new URLSearchParams({ limit: String(PAGE_LIMIT), status })
+    if (inner) params.set('cursor', inner)
+    const result = await requestSpaces(params)
+    if (!result.ok) return result.response
+    const data = result.data
 
     let nextInner: string | undefined
-    const nextLink = data._links?.next as string | undefined
+    const nextLink = data._links?.next
     if (nextLink) {
       try {
         nextInner = new URL(nextLink, 'https://placeholder').searchParams.get('cursor') || undefined
@@ -167,17 +196,14 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
       }
     }
 
-    // An exact-key lookup is a single resolution, never a page in a drained stream.
     let nextCursor: string | undefined
-    if (spaceKey) {
-      nextCursor = undefined
-    } else if (nextInner) {
+    if (nextInner) {
       nextCursor = `${status}:${nextInner}`
     } else if (status === 'current') {
       nextCursor = 'archived:'
     }
 
-    return NextResponse.json({ spaces, nextCursor })
+    return NextResponse.json({ spaces: toSpaces(data.results, status), nextCursor })
   } catch (error) {
     logger.error('Error listing Confluence spaces:', error)
     return NextResponse.json(

apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/connector-selector-field/connector-selector-field.tsx

@@ -194,9 +194,9 @@ function getEmptyMessage(
 ): string {
   // `field.title` is singular on some connectors ("Base") and plural on others
   // ("Spaces"), so only the settled message puts the noun behind a quantifier.
-  if (state.error) return 'No match — the list is incomplete. Enter the value directly'
+  if (state.error) return 'No match — the list failed to load. Try reopening'
   if (state.hasMore || state.isFetchingMore) return 'No match yet — still loading…'
-  if (state.truncated) return 'No match in what loaded — enter the value directly'
+  if (state.truncated) return 'No match — too many to list. Try a more exact term'
   return `No ${noun} found`
 }
 

apps/sim/hooks/selectors/providers/confluence/selectors.ts

@@ -89,13 +89,16 @@ export const confluenceSelectors = {
     ],
     enabled: ({ context }) => Boolean(context.oauthCredential && context.domain),
     /**
-     * Paged rather than a single fetch: `/pages` is cursor-paginated, so one request
-     * returned only the first `limit` pages of however many exist and the rest were
-     * unreachable — a search for a real page silently found nothing. `search` is
-     * still forwarded as the server-side `title` filter, and pagination now applies
-     * to the filtered stream too.
+     * Deliberately a single request, not a drain. `/pages` is cursor-paginated and
+     * this list is therefore capped at `limit`, which is a real gap — but draining it
+     * is worse: with no search term `title` is unset, so the drain would walk the
+     * entire site (up to `MAX_AUTO_DRAIN_PAGES` requests) every time the dropdown
+     * opens, and the route does not forward an abort signal upstream, so superseded
+     * drains still bill the tenant's rate limit. Fixing this properly needs
+     * server-side search whose `title` semantics have been confirmed against a live
+     * instance, not brute-force loading.
      */
-    fetchPage: async ({ context, search, cursor, signal }) => {
+    fetchList: async ({ context, search, signal }: SelectorQueryArgs) => {
       const credentialId = ensureCredential(context, 'confluence.pages')
       const domain = ensureDomain(context, 'confluence.pages')
       const bundle = await fetchOAuthToken(credentialId, context.workflowId)
@@ -108,17 +111,13 @@ export const confluenceSelectors = {
           accessToken: bundle.accessToken,
           cloudId: bundle.cloudId,
           title: search,
-          cursor,
         },
         signal,
       })
-      return {
-        items: (data.files || []).map((file) => ({
-          id: file.id,
-          label: file.name,
-        })),
-        nextCursor: data.nextCursor,
-      }
+      return (data.files || []).map((file) => ({
+        id: file.id,
+        label: file.name,
+      }))
     },
     fetchById: async ({ context, detailId, signal }: SelectorQueryArgs) => {
       if (!detailId) return null

apps/sim/hooks/selectors/use-selector-query.ts

@@ -178,18 +178,23 @@ export function useSelectorOptionDetail(
     detailId: resolvedDetailId,
   }
   const hasRealDetailId = Boolean(resolvedDetailId)
-  const baseEnabled =
-    hasRealDetailId && definition.fetchById !== undefined
-      ? definition.enabled
-        ? definition.enabled(queryArgs)
-        : true
-      : false
   /**
-   * A caller's `enabled` narrows `baseEnabled` rather than replacing it: `queryFn`
-   * asserts `fetchById` is defined, so dropping that guard would throw for every
-   * selector that declares no `fetchById`.
+   * Hard precondition: `queryFn` asserts `fetchById` is defined, so this must hold
+   * however the caller configures the query — otherwise the assertion throws for the
+   * many selectors that declare no `fetchById`.
    */
-  const enabled = (args.enabled ?? true) && baseEnabled
+  const canResolveDetail = hasRealDetailId && definition.fetchById !== undefined
+  /**
+   * `definition.enabled` describes when the *list* can be fetched, so it gates on
+   * context a list needs (credential, domain, region). Resolving one already-known id
+   * can need far less — `cloudwatch.*` echoes the id back without calling AWS at all —
+   * so a caller that opts in explicitly is only narrowed by the hard precondition.
+   * Callers that pass nothing keep the list predicate as their default.
+   */
+  const enabled =
+    args.enabled !== undefined
+      ? args.enabled && canResolveDetail
+      : canResolveDetail && (definition.enabled ? definition.enabled(queryArgs) : true)
 
   const query = useQuery<SelectorOption | null>({
     queryKey: [...definition.getQueryKey(queryArgs), 'detail', resolvedDetailId ?? 'none'],

apps/sim/lib/api/contracts/selectors/confluence.ts

@@ -24,8 +24,6 @@ export const confluencePagesBodySchema = z.object({
   cloudId: optionalString,
   title: optionalString,
   limit: z.number().int().positive().optional().default(50),
-  /** Opaque Confluence cursor for the next page, echoed back from `nextCursor`. */
-  cursor: optionalString,
 })
 
 /**
@@ -388,7 +386,7 @@ export const confluenceSpacesSelectorContract = definePostSelector(
 export const confluencePagesSelectorContract = definePostSelector(
   '/api/tools/confluence/pages',
   confluencePagesBodySchema,
-  z.object({ files: z.array(fileOptionSchema), nextCursor: optionalString })
+  z.object({ files: z.array(fileOptionSchema) })
 )
 
 export const confluencePageSelectorContract = definePostSelector(

packages/emcn/src/components/combobox/combobox.tsx

@@ -205,8 +205,16 @@ const Combobox = memo(
        */
       const onSearchChangeRef = useRef(onSearchChange)
       onSearchChangeRef.current = onSearchChange
-      /** Single write path for the search box so `onSearchChange` cannot be missed on a reset. */
+      /**
+       * Single write path for the search box so `onSearchChange` cannot be missed on a
+       * reset. Deduped because several paths reset redundantly — Escape both handles the
+       * key and lets the popover dismiss, and an editable select blurs after selecting —
+       * which `setSearchQuery` absorbed silently but a consumer callback would not.
+       */
+      const searchQueryRef = useRef('')
       const updateSearchQuery = useCallback((next: string) => {
+        if (searchQueryRef.current === next) return
+        searchQueryRef.current = next
         setSearchQuery(next)
         onSearchChangeRef.current?.(next)
       }, [])