@kortix/ui 0.14.7 → 0.14.9

package/dist/customize/connectors/catalog/connector-browse.js

@@ -1,8 +1,8 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useTranslations } from '../../../i18n/index.js';
-import { GlobeIcon, MonitorIcon } from '@phosphor-icons/react';
-import { memo, useState } from 'react';
+import { GlobeIcon } from '@phosphor-icons/react';
+import { memo } from 'react';
 import { Badge } from '../../../primitives/badge.js';
 import { Button } from '../../../primitives/button.js';
 import Loading from '../../../primitives/loading.js';
@@ -13,13 +13,13 @@ import { CatalogCardSkeleton, CatalogGrid, } from '../../shared/catalog/catalog-
 import { DENSE_GRID_CLASSNAME, DENSE_GRID_CONTAINER_CLASSNAME, } from '../../shared/catalog/catalog-grid-tokens.js';
 import { cn } from '../../../internal/lib/utils.js';
 import { InstallButton } from '../install/install-menu.js';
-import { catalogEntryKindLabel, isCatalogEntryConnected } from './catalog-entry.js';
+import { ConnectorLogo } from '../../../internal/connector-logo/connector-logo.js';
+import { catalogEntryKindLabel, catalogEntryLogoSource, isCatalogEntryConnected, } from './catalog-entry.js';
 import { catalogFootSummary } from './catalog-foot.js';
 import { useCatalogAutoload } from './use-catalog-autoload.js';
-/** The Install control is offered only where the caller may add the app, and
- *  never on the computer card: a computer is paired, not installed. */
-function canInstallEntry(entry, install) {
-    return install.canWrite && entry.source !== 'computer';
+/** The Install control is offered only where the caller may add the app. */
+function canInstallEntry(install) {
+    return install.canWrite;
 }
 /**
  * What a catalogue card offers on its right edge: "Added" when the project has
@@ -35,44 +35,15 @@ function CatalogAffordance({ entry, connected, install, }) {
     if (connected) {
         return (_jsx(Badge, { variant: "success", size: "sm", "data-testid": "catalog-connected", children: t('added') }));
     }
-    if (!canInstallEntry(entry, install))
+    if (!canInstallEntry(install))
         return null;
-    return (_jsx(InstallButton, { label: t('install'), variant: "outline", className: "gap-1 rounded-full", "aria-label": t('installNamed', { name: entry.name }), onInstall: () => install.onInstall(entry), pending: install.pendingKey === entry.slug, 
+    // What Kortix built is set up on its own page, not installed.
+    const channel = entry.source === 'discover' && entry.connector.kind === 'kortix';
+    return (_jsx(InstallButton, { label: channel ? t('waySetUp') : t('install'), variant: "outline", className: "gap-1 rounded-full", "aria-label": channel ? t('setUpNamed', { name: entry.name }) : t('installNamed', { name: entry.name }), onInstall: () => install.onInstall(entry), pending: install.pendingKey === entry.slug, 
         // `pendingKey` holds one install. A second one started beside it would
         // clear the first one's pending state when it settles.
         disabled: !install.ready || install.pendingKey !== null, "data-testid": "catalog-add" }));
 }
-/**
- * A catalog favicon, or a neutral glyph tile when the record has none or its
- * URL fails to load.
- *
- * A plain `<img>`, not `next/image`. These are third-party favicons on
- * arbitrary hosts, so the loader was already bypassed with `unoptimized` — which
- * left `fill` costing an absolutely-positioned child inside a `relative`
- * wrapper, per card, for no optimisation in return. Native `loading="lazy"`
- * defers every icon below the fold, which is most of them on a browse page.
- *
- * `width`/`height` are set so the box is reserved before the image arrives and
- * the grid never reflows around a late favicon.
- *
- * The broken-image state is the fallback the null case already had: a logo
- * URL that 404s used to render the browser's broken-image glyph inside the
- * tile, which is worse than no imagery at all. `onError` swaps to the same
- * glyph tile — the same fallback a record with no icon gets, so "missing" and
- * "unavailable" look identical. Mirrors `ConnectorAppIcon`'s broken state.
- *
- * The latch is per URL (`failedUrl`, not a boolean): a URL that failed stays
- * failed, while a swapped URL gets a fresh try without any call-site key —
- * merge-search swaps a merged twin's icon to the managed logo as catalogue
- * pages stream in.
- */
-export function ConnectorIcon({ icon, computer = false, }) {
-    const [failedUrl, setFailedUrl] = useState(null);
-    if (!icon || failedUrl === icon) {
-        return (_jsx("span", { className: "bg-card flex size-9 shrink-0 items-center justify-center rounded-sm", children: computer ? _jsx(MonitorIcon, { className: "size-5" }) : _jsx(GlobeIcon, { className: "size-5" }) }));
-    }
-    return (_jsx("span", { className: "flex size-9 shrink-0 items-center justify-center overflow-hidden rounded-sm", children: _jsx("img", { src: icon, alt: "", width: 36, height: 36, loading: "lazy", decoding: "async", referrerPolicy: "no-referrer", className: "size-9 object-contain", onError: () => setFailedUrl(icon) }) }));
-}
 /**
  * One catalogue card: icon and title on the bare page — no border, no
  * description — with one quiet line under the title saying how the entry
@@ -81,24 +52,22 @@ export function ConnectorIcon({ icon, computer = false, }) {
  * `memo`'d because the grid renders several hundred of these. `entry` and `connectedKeys` are referentially stable
  * across a page landing (the arrays they come from are rebuilt, but the entry
  * objects inside them are not), so the comparison actually pays off.
- * `hrefFor`, `onOpen` and `install` must be stable for the same reason;
+ * `hrefFor` and `install` must be stable for the same reason;
  * `install` changes identity only when an install starts or ends.
  */
-const CatalogEntryCard = memo(function CatalogEntryCard({ entry, connectedKeys, hrefFor, onOpen, install, }) {
+const CatalogEntryCard = memo(function CatalogEntryCard({ entry, connectedKeys, hrefFor, install, }) {
     const href = hrefFor(entry);
     const connected = isCatalogEntryConnected(entry, connectedKeys);
     const shared = {
         variant: 'plain',
-        leading: _jsx(ConnectorIcon, { icon: entry.icon, computer: entry.source === 'computer' }),
+        leading: _jsx(ConnectorLogo, { source: catalogEntryLogoSource(entry), size: "lg" }),
         title: entry.name,
         subtitle: _jsx("span", { className: "text-muted-foreground text-xs", children: catalogEntryKindLabel(entry) }),
         trailing: _jsx(CatalogAffordance, { entry: entry, connected: connected, install: install }),
     };
-    // An entry with no page of its own (the computer card) opens in place.
-    return href ? (
     // Only the Install control needs to sit beside the link. The "Added" badge
     // stays inside it, so a click on the badge still opens the page.
-    _jsx(CatalogCard, { ...shared, href: href, trailingInteractive: !connected && canInstallEntry(entry, install) })) : (_jsx(CatalogCard, { ...shared, onClick: () => onOpen(entry) }));
+    return (_jsx(CatalogCard, { ...shared, href: href, trailingInteractive: !connected && canInstallEntry(install) }));
 });
 /** Skeletons appended to a growing grid while a request is in flight. Six —
  *  two full rows of the widest layout — so the placeholder block is the same
@@ -120,7 +89,7 @@ function CatalogFoot({ summary, hasMore, isLoadingMore, loadMore, }) {
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
     if (!hasMore && summary === null)
         return null;
-    return (_jsxs("div", { className: "flex flex-col items-center gap-2 pt-2", children: [hasMore && !isLoadingMore ? (_jsx(Button, { variant: "outline", size: "sm", onClick: loadMore, className: "transition-transform duration-(--duration-normal) ease-out active:scale-[0.96]", children: tI18nComplete.raw('textac8991ef0101') })) : null, summary ? (_jsxs("p", { className: "text-muted-foreground/70 flex items-center gap-2 text-xs tabular-nums", role: isLoadingMore ? 'status' : undefined, "aria-live": isLoadingMore ? 'polite' : undefined, children: [isLoadingMore ? _jsx(Loading, { className: "size-3.5 shrink-0" }) : null, summary] })) : null] }));
+    return (_jsxs("div", { className: "flex flex-col items-center gap-2 pt-2", children: [hasMore && !isLoadingMore ? (_jsx(Button, { variant: "outline", size: "sm", onClick: loadMore, className: "transition-transform duration-(--duration-normal) ease-out active:scale-[0.96]", children: tI18nComplete.raw('textac8991ef0101') })) : null, summary ? (_jsxs("p", { className: "text-muted-foreground flex items-center gap-2 text-xs tabular-nums", role: isLoadingMore ? 'status' : undefined, "aria-live": isLoadingMore ? 'polite' : undefined, children: [isLoadingMore ? _jsx(Loading, { className: "size-3.5 shrink-0" }) : null, summary] })) : null] }));
 }
 /**
  * The catalogue body: one flat, paginated, searchable grid.
@@ -130,7 +99,7 @@ function CatalogFoot({ summary, hasMore, isLoadingMore, loadMore, }) {
  * no per-category deepening loop, no reveal window uncovering already-loaded
  * cards.
  */
-export function ConnectorBrowse({ state, connectedKeys, hrefFor, onOpen, install, emptyTitle, emptyDescription, suppressNoMatch = false, }) {
+export function ConnectorBrowse({ state, connectedKeys, hrefFor, install, emptyTitle, emptyDescription, suppressNoMatch = false, }) {
     const { activeQuery, entries, total } = state;
     const searching = activeQuery.length > 0;
     const hasMore = state.hasMore;
@@ -149,7 +118,7 @@ export function ConnectorBrowse({ state, connectedKeys, hrefFor, onOpen, install
     // documented order, so those three states are delegated here and the grid
     // gets no children it could render.
     if (state.isLoading || state.isError || isEmpty) {
-        return (_jsx(CatalogGrid, { isLoading: state.isLoading, isError: state.isError, error: state.error, onRetry: state.refetch, isEmpty: true, empty: searching ? (suppressNoMatch ? null : (_jsx(CatalogNoMatch, { query: activeQuery, excludedNoActions: state.excludedNoActions }))) : (_jsx(EmptyState, { icon: GlobeIcon, size: "sm", title: emptyTitle, description: emptyDescription })), children: null }));
+        return (_jsx(CatalogGrid, { isLoading: state.isLoading, isError: state.isError, error: state.error, onRetry: state.refetch, isEmpty: true, empty: searching ? (suppressNoMatch ? null : (_jsx(CatalogNoMatch, { query: activeQuery }))) : (_jsx(EmptyState, { icon: GlobeIcon, size: "sm", title: emptyTitle, description: emptyDescription })), children: null }));
     }
     const summary = catalogFootSummary({
         loaded: entries.length,
@@ -158,7 +127,7 @@ export function ConnectorBrowse({ state, connectedKeys, hrefFor, onOpen, install
         hasMore,
         isLoadingMore: state.isLoadingMore,
     });
-    return (_jsxs("div", { "aria-busy": state.isRefreshing || undefined, className: cn('space-y-6 transition-opacity duration-(--duration-normal) ease-out', state.isRefreshing && 'pointer-events-none opacity-60'), children: [_jsx("div", { className: DENSE_GRID_CONTAINER_CLASSNAME, children: _jsxs("div", { className: DENSE_GRID_CLASSNAME, children: [entries.map((entry) => (_jsx(CatalogEntryCard, { entry: entry, connectedKeys: connectedKeys, hrefFor: hrefFor, onOpen: onOpen, install: install }, entry.key))), state.isLoadingMore
+    return (_jsxs("div", { "aria-busy": state.isRefreshing || undefined, className: cn('space-y-6 transition-opacity duration-(--duration-normal) ease-out', state.isRefreshing && 'pointer-events-none opacity-60'), children: [_jsx("div", { className: DENSE_GRID_CONTAINER_CLASSNAME, children: _jsxs("div", { className: DENSE_GRID_CLASSNAME, children: [entries.map((entry) => (_jsx(CatalogEntryCard, { entry: entry, connectedKeys: connectedKeys, hrefFor: hrefFor, install: install }, entry.key))), state.isLoadingMore
                             ? Array.from({ length: LOADING_MORE_SKELETONS }, (_, index) => (_jsx(CatalogCardSkeleton, {}, `loading-${index}`)))
                             : null] }) }), hasMore ? _jsx("div", { ref: sentinelRef, "aria-hidden": true, className: "h-px" }) : null, _jsx(CatalogFoot, { summary: summary, hasMore: hasMore, isLoadingMore: state.isLoadingMore, loadMore: loadMore })] }));
 }

package/dist/customize/connectors/catalog/use-catalog.d.ts

@@ -1,6 +1,6 @@
-import { getConnectStatus, listDiscoverConnectors } from '@kortix/sdk';
+import { getConnectStatus, type DiscoverConnectorKind } from '@kortix/sdk';
 import { type BrowseSectionsPage } from './browse-sections.js';
-import { computersCatalogEntry, type CatalogEntry, type CatalogSource } from './catalog-entry.js';
+import { type CatalogEntry } from './catalog-entry.js';
 /**
  * One browse section: a category, a fixed slice of it, and its true size.
  *
@@ -22,14 +22,6 @@ export interface CatalogState {
     total: number;
     /** The debounced query actually in flight, trimmed. Empty when browsing. */
     activeQuery: string;
-    /** Which catalogue answered. Decides the add flow a card opens. */
-    source: CatalogSource;
-    /** Categories the user can filter by, each with its true count. Empty for
-     *  the Discover source and while the Easy Connect index is still building. */
-    /** Apps matching the query that publish no actions, so the catalogue does
-     *  not offer them. Lets the no-match state say why instead of implying the
-     *  app does not exist — `q=SAP` is exactly this case. */
-    excludedNoActions: number;
     /** The browse page. Empty while searching or inside a category — both are
      *  one flat result set by definition. */
     sections: CatalogSection[];
@@ -90,12 +82,15 @@ export declare const connectStatusQuery: {
     queryFn: typeof getConnectStatus;
 };
 /**
- * The browse page's one request, keyed per catalogue. Exported so the
- * Customize prefetch (`use-customize-prefetch.ts`) fills the exact cache entry
- * the Discover landing reads.
+ * The browse page's one request. Exported so the Customize prefetch
+ * (`use-customize-prefetch.ts`) fills the exact cache entry the landing reads.
  */
-export declare function catalogSectionsQuery(projectId: string, catalogue: 'kortix' | 'discover' | 'composio' | 'pipedream' | null): {
-    queryKey: readonly ["catalog-sections", string, "kortix" | "composio" | "pipedream" | "discover" | null];
+export declare function catalogSectionsQuery(projectId: string, 
+/** Just the apps that connect with nothing to set up. */
+oneClick?: boolean, 
+/** Just the apps that connect these ways. */
+kinds?: readonly DiscoverConnectorKind[]): {
+    queryKey: readonly ["catalog-sections", string, "kortix", ...string[]];
     queryFn: () => Promise<BrowseSectionsPage>;
     staleTime: number;
 };
@@ -108,54 +103,20 @@ export declare function listConnectCatalogPage(input: {
     limit: number;
 }): Promise<import("@kortix/sdk").PipedreamCatalogPage>;
 /**
- * The catalogue behind the All tab, from whichever of the two
- * sources this project actually has.
- *
- * **Why two sources.** `connectors_api_discover` resolves to `false` by
- * default (`apps/api/src/experimental/features.ts:83`), so the Discover
- * catalogue is unavailable to most projects. Easy Connect (Pipedream) is not
- * flagged. Falling back keeps the page populated for every project.
- *
- * **Why not merge them.** The two publish overlapping apps under different
- * slugs and different `id` namespaces, and each has its own add flow. A merged
- * list would need a cross-catalogue identity that neither API provides.
+ * The catalogue behind the All tab: Kortix's apps, every integrations.sh
+ * server and API, and the Composio apps, each app once by its best way in
+ * (`apps/api/src/connectors/mcp-apps.ts`). One source, the Discover routes.
  *
  * **One paging mechanism.** A scroll or a click on "Load more" fetches the next
- * page. That is all. This replaces a three-layer arrangement — eager initial
- * pages, a per-category auto-deepening effect chain, and a client-side reveal
- * window over the top — that existed only because the client had to accumulate
- * enough pages to fake a category filter. The server filters by category now
- * (`pipedreamCatalogPage`), so the client asks for exactly the page it renders.
- *
- * **Filtering happens server-side, over the whole catalogue.** Both `q` and
- * `category` are query keys, so changing either starts a new list rather than
- * re-slicing an accumulated one. Pipedream's own API cannot filter by category
- * at all — see `apps/api/src/connectors/pipedream-index.ts`.
- *
- * **Easy Connect waits for the deployment probe.** No Pipedream request is sent
- * until `usePipedreamStatus` has ruled out `absent`, because on a deployment
- * without Pipedream credentials every one of them is a `501` — and one landing
- * before the probe would paint the error card the probe exists to prevent. The
- * cost is one round trip on the first load of the session, spent on a route that
- * only reads env vars, and the wait is reported as `isLoading` so the grid holds
- * its skeletons instead of flashing an empty result.
+ * page. `q`, `oneClick` and `kinds` are query keys, so changing any of them
+ * starts a new list rather than re-slicing an accumulated one.
  */
 export declare function useCatalog(projectId: string, query: string, opts: {
     enabled: boolean;
-    /** The API/MCP catalogue is on for this project (`connectors_api_discover`). */
-    discoverEnabled: boolean;
-    /** `connectors_v2`: the catalogue is Kortix's own MCP apps, served on the
-     *  Discover routes. No Composio or Pipedream request is sent. */
-    mcpApps?: boolean;
-    /** Show the native Computer card: this deployment can connect computers. */
+    /** This deployment can pair computers; without it the Computer record goes. */
     computers?: boolean;
+    /** List just the apps that connect with nothing to set up. */
+    oneClick?: boolean;
+    /** List just the apps that connect these ways. */
+    kinds?: readonly DiscoverConnectorKind[];
 }): CatalogState;
-export declare function assembleCatalogEntries({ source, computers, activeQuery, searchDirect, tI18nComplete, discoverPages, managedPages, }: {
-    source: CatalogSource;
-    computers: boolean;
-    activeQuery: string;
-    searchDirect: boolean;
-    tI18nComplete: Parameters<typeof computersCatalogEntry>[0];
-    discoverPages?: Awaited<ReturnType<typeof listDiscoverConnectors>>[];
-    managedPages?: Awaited<ReturnType<typeof listConnectCatalogPage>>[];
-}): CatalogEntry[];

package/dist/customize/connectors/catalog/use-catalog.js

@@ -1,16 +1,12 @@
 'use client';
-import { getConnectStatus, listConnectSections, listConnectToolkits, listDiscoverConnectors, listDiscoverSections, listPipedreamApps, listPipedreamSections, } from '@kortix/sdk';
+import { getConnectStatus, listConnectToolkits, listDiscoverConnectors, listDiscoverSections, listPipedreamApps, } from '@kortix/sdk';
 import { keepPreviousData, useInfiniteQuery, useQuery } from '@tanstack/react-query';
 import { useCallback, useMemo } from 'react';
 import { useDebounce } from '../../../hooks/use-debounce.js';
 import { useTranslations } from '../../../i18n/index.js';
-import { browseSections, connectToolkitApp, sectionsPageFromConnect, sectionsPageFromDiscover, sectionsPageFromPipedream, } from './browse-sections.js';
-import { catalogEntryFromDiscover, catalogEntryFromEasyConnect, computersCatalogEntry, } from './catalog-entry.js';
+import { browseSections, sectionsPageFromDiscover } from './browse-sections.js';
+import { catalogEntryFromDiscover, connectToolkitApp } from './catalog-entry.js';
 import { CATEGORY_ROW_CAP, localizedSectionTitle } from './connector-categories.js';
-import { mergeSearchEntries } from './merge-search.js';
-/** Apps per request. One page fills several rows of the widest grid, so a
- *  scroll-triggered fetch is felt as the grid growing rather than as a jump. */
-const CATALOG_PAGE_SIZE = 48;
 /** Cards per section on the browse page, and how many sections it shows.
  *  `CATEGORY_ROW_CAP` is two rows of `xl:grid-cols-3`; 12 sections is a browse
  *  page you can scan without it becoming a directory of headings. */
@@ -76,25 +72,22 @@ export const connectStatusQuery = {
     queryFn: getConnectStatus,
 };
 /**
- * The browse page's one request, keyed per catalogue. Exported so the
- * Customize prefetch (`use-customize-prefetch.ts`) fills the exact cache entry
- * the Discover landing reads.
+ * The browse page's one request. Exported so the Customize prefetch
+ * (`use-customize-prefetch.ts`) fills the exact cache entry the landing reads.
  */
-export function catalogSectionsQuery(projectId, catalogue) {
+export function catalogSectionsQuery(projectId, 
+/** Just the apps that connect with nothing to set up. */
+oneClick = false, 
+/** Just the apps that connect these ways. */
+kinds = []) {
     return {
-        queryKey: ['catalog-sections', projectId, catalogue],
-        queryFn: async () => {
-            const limits = { perCategory: SECTION_CARD_COUNT, maxCategories: SECTION_COUNT };
-            // `kortix` is the same Discover route: the API serves Kortix's own MCP
-            // apps to a `connectors_v2` project (apps/api/src/connectors/mcp-apps.ts).
-            if (catalogue === 'discover' || catalogue === 'kortix') {
-                return sectionsPageFromDiscover(await listDiscoverSections(projectId, limits));
-            }
-            if (catalogue === 'pipedream') {
-                return sectionsPageFromPipedream(await listPipedreamSections(projectId, limits));
-            }
-            return sectionsPageFromConnect(await listConnectSections(projectId, limits));
-        },
+        queryKey: ['catalog-sections', projectId, 'kortix', ...(oneClick ? ['one-click'] : []), ...kinds],
+        queryFn: async () => sectionsPageFromDiscover(await listDiscoverSections(projectId, {
+            perCategory: SECTION_CARD_COUNT,
+            maxCategories: SECTION_COUNT,
+            ...(oneClick ? { oneClick } : {}),
+            ...(kinds.length ? { kinds: [...kinds] } : {}),
+        })),
         staleTime: 5 * 60_000,
     };
 }
@@ -119,129 +112,43 @@ export async function listConnectCatalogPage(input) {
     };
 }
 /**
- * The catalogue behind the All tab, from whichever of the two
- * sources this project actually has.
- *
- * **Why two sources.** `connectors_api_discover` resolves to `false` by
- * default (`apps/api/src/experimental/features.ts:83`), so the Discover
- * catalogue is unavailable to most projects. Easy Connect (Pipedream) is not
- * flagged. Falling back keeps the page populated for every project.
- *
- * **Why not merge them.** The two publish overlapping apps under different
- * slugs and different `id` namespaces, and each has its own add flow. A merged
- * list would need a cross-catalogue identity that neither API provides.
+ * The catalogue behind the All tab: Kortix's apps, every integrations.sh
+ * server and API, and the Composio apps, each app once by its best way in
+ * (`apps/api/src/connectors/mcp-apps.ts`). One source, the Discover routes.
  *
  * **One paging mechanism.** A scroll or a click on "Load more" fetches the next
- * page. That is all. This replaces a three-layer arrangement — eager initial
- * pages, a per-category auto-deepening effect chain, and a client-side reveal
- * window over the top — that existed only because the client had to accumulate
- * enough pages to fake a category filter. The server filters by category now
- * (`pipedreamCatalogPage`), so the client asks for exactly the page it renders.
- *
- * **Filtering happens server-side, over the whole catalogue.** Both `q` and
- * `category` are query keys, so changing either starts a new list rather than
- * re-slicing an accumulated one. Pipedream's own API cannot filter by category
- * at all — see `apps/api/src/connectors/pipedream-index.ts`.
- *
- * **Easy Connect waits for the deployment probe.** No Pipedream request is sent
- * until `usePipedreamStatus` has ruled out `absent`, because on a deployment
- * without Pipedream credentials every one of them is a `501` — and one landing
- * before the probe would paint the error card the probe exists to prevent. The
- * cost is one round trip on the first load of the session, spent on a route that
- * only reads env vars, and the wait is reported as `isLoading` so the grid holds
- * its skeletons instead of flashing an empty result.
+ * page. `q`, `oneClick` and `kinds` are query keys, so changing any of them
+ * starts a new list rather than re-slicing an accumulated one.
  */
 export function useCatalog(projectId, query, opts) {
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
     const { debouncedValue: activeQuery } = useDebounce(query.trim(), 300);
-    const computers = opts.computers === true;
+    const hideComputerRecord = opts.computers !== true;
     const searching = activeQuery.length > 0;
-    // Always probed, whether or not the catalogue is `enabled`: the answer picks
-    // the source, and `ConnectorsPage` turns the All tab OFF when it is `absent`
-    // with no API/MCP catalogue either. It is one cached request.
-    const connectStatus = useConnectProviderStatus(true);
-    // One catalogue, no source toggle. Managed apps drive browsing; a search also
-    // asks the API/MCP catalogue (below). With no managed provider on this
-    // deployment, the API/MCP catalogue is the whole catalogue.
-    // `unknown` (the probe failed) falls back to the API/MCP catalogue too, as
-    // before the merge of the two.
-    const mcpApps = opts.mcpApps === true;
-    const source = mcpApps ||
-        (opts.discoverEnabled && (connectStatus.state === 'absent' || connectStatus.state === 'unknown'))
-        ? 'discover'
-        : 'easy-connect';
-    const searchDirect = opts.discoverEnabled && source === 'easy-connect' && searching;
-    // Keys the Discover cache by the catalogue the API answers with.
-    const discoverCatalogue = mcpApps ? 'kortix' : 'discover';
-    // `unknown` proceeds: the probe failed, and refusing to load a catalogue that
-    // may well exist is the worse of the two mistakes.
-    const easyConnectRunnable = source === 'easy-connect' &&
-        (connectStatus.state === 'configured' || connectStatus.state === 'unknown');
-    const easyConnectProvider = connectStatus.provider ?? 'composio';
+    const oneClick = opts.oneClick === true;
+    const kinds = useMemo(() => [...(opts.kinds ?? [])], [opts.kinds]);
     const discoverQuery = useInfiniteQuery({
-        // An open category is a server-side filter, so it is part of the key. The
-        // unfiltered key stays exactly the one `discover-catalogue.tsx` shares.
-        queryKey: mcpApps
-            ? ['discover-connectors', projectId, activeQuery, 'kortix']
-            : ['discover-connectors', projectId, activeQuery],
+        queryKey: ['discover-connectors', projectId, activeQuery, 'kortix', oneClick, ...kinds],
         queryFn: ({ pageParam }) => listDiscoverConnectors(projectId, {
             q: activeQuery || undefined,
             cursor: pageParam,
+            ...(oneClick ? { oneClick } : {}),
+            ...(kinds.length ? { kinds } : {}),
         }),
         initialPageParam: undefined,
         getNextPageParam: (last) => (last.hasMore ? last.nextCursor : undefined),
         staleTime: 5 * 60_000,
-        enabled: opts.enabled && (source === 'discover' || searchDirect),
-        placeholderData: keepPreviousData,
-    });
-    const easyConnectQuery = useInfiniteQuery({
-        queryKey: ['easy-connect-apps', projectId, activeQuery, null],
-        queryFn: ({ pageParam }) => listConnectCatalogPage({
-            projectId,
-            provider: easyConnectProvider,
-            q: activeQuery || undefined,
-            cursor: pageParam,
-            limit: CATALOG_PAGE_SIZE,
-        }),
-        initialPageParam: undefined,
-        getNextPageParam: (last) => (last.hasMore ? last.nextCursor : undefined),
-        staleTime: 60_000,
-        enabled: opts.enabled && easyConnectRunnable,
+        enabled: opts.enabled,
         placeholderData: keepPreviousData,
     });
-    // The browse page, in one request, from whichever catalogue this project
-    // uses. Every one answers with each category's TRUE size, so a heading never
-    // reports how many cards one loaded page happened to hold.
-    //
-    // Fetched while browsing. Discover and Composio also keep it while a category
-    // is open: their paged endpoints publish no category facet, and this
-    // response's facet is what lets the open category's header state its name
-    // and size. Same key, so opening a category from the browse page costs no
-    // request. Pipedream's paged endpoint carries its own facet.
-    const sectionsCatalogue = source === 'discover' ? discoverCatalogue : easyConnectProvider;
+    // The browse page, in one request. It answers with each category's TRUE
+    // size, so a heading never reports how many cards one loaded page held.
     const sectionsQuery = useQuery({
-        ...catalogSectionsQuery(projectId, sectionsCatalogue),
-        enabled: opts.enabled && (source === 'discover' || easyConnectRunnable) && !searching,
+        ...catalogSectionsQuery(projectId, oneClick, kinds),
+        enabled: opts.enabled && !searching,
     });
-    const active = source === 'discover' ? discoverQuery : easyConnectQuery;
-    const entries = useMemo(() => assembleCatalogEntries({
-        source,
-        computers,
-        activeQuery,
-        searchDirect,
-        tI18nComplete,
-        discoverPages: discoverQuery.data?.pages,
-        managedPages: easyConnectQuery.data?.pages,
-    }), [
-        searchDirect,
-        tI18nComplete,
-        computers,
-        activeQuery,
-        source,
-        easyConnectQuery.data?.pages,
-        discoverQuery.data?.pages,
-    ]);
-    const { fetchNextPage, hasNextPage, isFetchingNextPage, isPlaceholderData, refetch: activeRefetch, } = active;
+    const entries = useMemo(() => withoutComputerRecord(hideComputerRecord, (discoverQuery.data?.pages ?? []).flatMap((page) => page.items.map(catalogEntryFromDiscover))), [hideComputerRecord, discoverQuery.data?.pages]);
+    const { fetchNextPage, hasNextPage, isFetchingNextPage, isPlaceholderData, refetch: activeRefetch, } = discoverQuery;
     // Stable identity: `useCatalogAutoload` lists this in its observer effect's
     // deps, and a new function every render would tear down and rebuild the
     // `IntersectionObserver` on each one.
@@ -261,27 +168,20 @@ export function useCatalog(projectId, query, opts) {
             void sectionsRefetch();
     }, [activeRefetch, sectionsRefetch, showingSections]);
     /**
-     * The browse sections, normalised across every catalogue so `ConnectorBrowse`
-     * renders one shape.
-     *
-     * All of them come from the server, complete and fixed, with each section's
-     * true total. A section key is exactly what the catalogue's category filter
-     * accepts, so "View all" asks the server for the set the heading counted.
+     * The browse sections. They come from the server, complete and fixed, with
+     * each section's true total. A section key is exactly what the catalogue's
+     * category filter accepts, so "View all" asks for the set the heading counted.
      */
     const sections = useMemo(() => {
         if (searching || !sectionsQuery.data)
             return [];
         return browseSections(sectionsQuery.data, {
-            native: computers ? computersCatalogEntry(tI18nComplete) : null,
             cardCount: SECTION_CARD_COUNT,
             title: (label) => localizedSectionTitle(label, tI18nComplete),
-        });
-    }, [searching, sectionsQuery.data, tI18nComplete, computers]);
-    const easyConnectPage = easyConnectQuery.data?.pages[0];
-    const excludedNoActions = easyConnectPage?.excludedNoActions ?? 0;
-    const reportedTotal = source === 'discover' ? discoverQuery.data?.pages[0]?.total : easyConnectPage?.total;
-    const nativeCount = entries.some((entry) => entry.source === 'computer') ? 1 : 0;
-    const total = typeof reportedTotal === 'number' ? reportedTotal + nativeCount : entries.length;
+        }).map((section) => ({ ...section, items: withoutComputerRecord(hideComputerRecord, section.items) }));
+    }, [searching, sectionsQuery.data, tI18nComplete, hideComputerRecord]);
+    const reportedTotal = discoverQuery.data?.pages[0]?.total;
+    const total = typeof reportedTotal === 'number' ? reportedTotal : entries.length;
     // A failed sections request on the browse page is an error, not an empty
     // catalogue — without this the grid would say "no connectors" over an outage.
     const sectionsFailed = showingSections && sectionsQuery.isError;
@@ -289,48 +189,21 @@ export function useCatalog(projectId, query, opts) {
         entries,
         total,
         activeQuery,
-        source,
-        excludedNoActions,
         sections,
         // `isLoading` is the COLD state only — no cards on screen at all. A search
         // over a populated catalogue keeps its results and reports `isRefreshing`,
         // so the grid dims instead of blanking to skeletons.
-        //
-        // `asking` counts as loading: the Easy Connect queries are held disabled
-        // until the deployment probe answers, and a disabled query reports neither
-        // loading nor data — without this the grid would render "no results" for a
-        // round trip before the real request had started.
-        isLoading: opts.enabled &&
-            (connectStatus.state === 'asking' ||
-                active.isLoading ||
-                (showingSections && sectionsQuery.isLoading)),
+        isLoading: opts.enabled && (discoverQuery.isLoading || (showingSections && sectionsQuery.isLoading)),
         isRefreshing: opts.enabled && isPlaceholderData,
-        isError: active.isError || sectionsFailed,
-        error: active.isError ? active.error : sectionsFailed ? sectionsQuery.error : null,
+        isError: discoverQuery.isError || sectionsFailed,
+        error: discoverQuery.isError ? discoverQuery.error : sectionsFailed ? sectionsQuery.error : null,
         hasMore: opts.enabled && hasNextPage && !isPlaceholderData,
         isLoadingMore: isFetchingNextPage,
         loadMore,
         refetch,
     };
 }
-export function assembleCatalogEntries({ source, computers, activeQuery, searchDirect, tI18nComplete, discoverPages, managedPages, }) {
-    const native = computersCatalogEntry(tI18nComplete);
-    // The native Computers card is ours, not the catalogue's, so it is matched
-    // locally and hidden inside a category it does not claim.
-    const includeComputers = computers &&
-        (!activeQuery ||
-            `${native.name} ${native.description ?? ''}`
-                .toLowerCase()
-                .includes(activeQuery.toLowerCase()));
-    const nativeEntries = includeComputers ? [native] : [];
-    if (source === 'discover') {
-        return nativeEntries.concat((discoverPages ?? []).flatMap((page) => page.items.map(catalogEntryFromDiscover)));
-    }
-    const managed = (managedPages ?? []).flatMap((page) => page.apps.map(catalogEntryFromEasyConnect));
-    if (!searchDirect)
-        return nativeEntries.concat(managed);
-    // ponytail: only the API/MCP catalogue's first page joins a search; its
-    // ranking puts the matches there. Page it too if users miss results.
-    const direct = (discoverPages?.[0]?.items ?? []).map(catalogEntryFromDiscover);
-    return nativeEntries.concat(mergeSearchEntries(managed, direct));
+/** The catalogue's Computer record (`native:computer`), dropped where no computer can be paired. */
+function withoutComputerRecord(hide, entries) {
+    return hide ? entries.filter((entry) => entry.key !== 'discover:native:computer') : entries;
 }

package/dist/customize/connectors/connector-identity.d.ts

@@ -1,21 +1,18 @@
 import type { AdminConnector } from '@kortix/sdk';
 /**
- * How a connector presents itself — its icon tile and its status pill.
+ * How a connector presents its status — the connected mark and the status
+ * pill. Its logo is `ConnectorLogo` (`connector-logo.tsx`), shared by every
+ * connector surface.
  *
  * These two render once per card in the connectors grid, so they sit on the
  * hottest path of `/projects/[id]/connectors`. They used to live in
  * `customize/sections/connectors-view.tsx`, which is ~5,100 lines across 50
- * components and pulls `HighlightedCode`,
- * `PoliciesPanel`, `DiscoverCatalogue` and `ConnectorConnectionModal`. Importing
+ * components and pulls `HighlightedCode` and `PoliciesPanel`. Importing
  * two small components from there put that entire graph in this route's client
  * chunk — an ES module is all-or-nothing to the bundler.
  *
  * The tile-size helper came along because nothing else in the old file used it.
  */
-export declare function ConnectorAppIcon({ connector, size, }: {
-    connector: AdminConnector;
-    size?: 'sm' | 'lg';
-}): import("react").JSX.Element;
 /**
  * Green `✓` for a healthy project connector — same glyph Discovery/All use in
  * the catalogue card's `trailing` slot. Not a badge: problem states keep the
@@ -26,10 +23,11 @@ export declare function ConnectorConnectedMark({ className }?: {
     className?: string;
 }): import("react").JSX.Element;
 /**
- * Problem / setup pills for a project connector. Deliberately returns `null`
- * when status is `connected` — put {@link ConnectorConnectedMark} in the card's
- * `trailing` slot instead so Connected matches Discovery's `✓` affordance.
+ * The state pill for a project connector: Needs account or Error. Connected
+ * returns `null`: put {@link ConnectorConnectedMark} in the card's `trailing`
+ * slot instead, the catalogue's `✓`.
  */
-export declare function ConnectorStatusBadge({ connector }: {
+export declare function ConnectorStatusBadge({ connector, accountCount, }: {
     connector: AdminConnector;
+    accountCount?: number;
 }): import("react").JSX.Element | null;