@kortix/ui 0.0.0-stage → 0.14.4

package/dist/customize/connectors/install/install-menu.d.ts

@@ -0,0 +1,19 @@
+export interface InstallButtonProps {
+    /** The visible label: "Install". */
+    label: string;
+    onInstall: () => void;
+    pending?: boolean;
+    disabled?: boolean;
+    variant?: 'default' | 'secondary' | 'outline';
+    /** Extra classes for the button. */
+    className?: string;
+    /** Names what is installed when a page has several of these. It must contain `label`. */
+    'aria-label'?: string;
+    'data-testid'?: string;
+}
+/**
+ * Install adds the app's connector PROFILE to the project, and asks nothing
+ * else. Who may use an account is chosen per account, in "Add account" on the
+ * connector page Install opens.
+ */
+export declare function InstallButton({ label, onInstall, pending, disabled, variant, className, 'aria-label': ariaLabel, 'data-testid': testId, }: InstallButtonProps): import("react").JSX.Element;

package/dist/customize/connectors/install/install-menu.js

@@ -0,0 +1,14 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../../primitives/button.js';
+import { SessionDotMatrix } from '../../../primitives/dot-matrix/session-dot-matrix.js';
+import { cn } from '../../../internal/lib/utils.js';
+/**
+ * Install adds the app's connector PROFILE to the project, and asks nothing
+ * else. Who may use an account is chosen per account, in "Add account" on the
+ * connector page Install opens.
+ */
+export function InstallButton({ label, onInstall, pending = false, disabled = false, variant = 'secondary', className, 'aria-label': ariaLabel, 'data-testid': testId, }) {
+    return (_jsxs(Button, { type: "button", size: "sm", variant: variant, className: cn(variant !== 'default' &&
+            'hover:border-ring hover:ring-ring/15 hit-area-y-3 hit-area-l-3 shrink-0 border border-transparent hover:border hover:ring-2', className), disabled: disabled || pending, "aria-label": ariaLabel, "data-testid": testId, onClick: onInstall, children: [pending ? _jsx(SessionDotMatrix, { size: 14, className: "shrink-0" }) : null, label] }));
+}

package/dist/customize/connectors/install/install.d.ts

@@ -0,0 +1,71 @@
+import type { AdminConnector, ConnectorDraftInput, ConnectorSyncResult } from '@kortix/sdk';
+import { type EasyConnectApp, type EasyConnectConnectionInput } from '../../sections/connector-connection-form.js';
+import type { InstallableVariant } from './pick-surface.js';
+/** One surface of one app, as Install needs it. */
+export interface InstallTarget {
+    /** The app's display name. The connector and its first account are named from it. */
+    appName: string;
+    provider: AdminConnector['provider'];
+    /** Authorization runs through a hosted Connect Link (Composio, Pipedream). */
+    managed: boolean;
+    /** A NEW direct connector needs a credential before it works. */
+    needsCredential: boolean;
+    buildDraft(input: EasyConnectConnectionInput): ConnectorDraftInput;
+}
+export declare function discoverInstallTarget(appName: string, variant: InstallableVariant): InstallTarget;
+export declare function easyConnectInstallTarget(app: EasyConnectApp): InstallTarget;
+/**
+ * Did Install create this connector for this app and surface?
+ *
+ * STRICT, because the answer decides where a new account is authorized. Three
+ * things must hold:
+ * - the provider matches;
+ * - the slug is exactly what `proposeConnectorConnectionSlug` builds for the
+ *   app's name, `<normalized name>-<6 base36>`, never a prefix;
+ * - the display name is what `proposeConnectorConnectionName` gives: the app's
+ *   name, or `<App> <n>` with n an integer of 2 or more. A six-character word
+ *   reads as a random suffix (`notion-search`, `google-sheets`), and the name
+ *   is what tells those apart.
+ *
+ * A renamed connector is therefore not reused. That miss costs a second
+ * connector, which is the cheap failure. A false hit would authorize the
+ * wrong app.
+ */
+export declare function connectorInstalledFrom(connector: Pick<AdminConnector, 'slug' | 'provider' | 'name'>, appName: string, provider: AdminConnector['provider']): boolean;
+/**
+ * The name a new account gets: the app's name, then `<name> 2`, `<name> 3`.
+ * `POST /connections` with a label an account of the same owner already uses
+ * updates that account instead of adding one, so the label must be free.
+ */
+export declare function proposeAccountLabel(appName: string, taken: readonly string[]): string;
+export interface InstallDeps {
+    createConnector(projectId: string, draft: ConnectorDraftInput): Promise<{
+        sync?: ConnectorSyncResult;
+    }>;
+    /** Slug suffix source; injectable so tests are deterministic. */
+    random?: () => string;
+}
+export type InstallResult = {
+    status: 'installed';
+    slug: string;
+}
+/** The profile exists; its page shows the error and Retry. */
+ | {
+    status: 'sync_failed';
+    slug: string;
+    name: string;
+    error: string;
+};
+/**
+ * Install = add the connector PROFILE to the project, nothing more.
+ *
+ * A profile is always the project's: the app, its config and its rules (a
+ * `kortix.yaml` entry). Who may use it is a property of each ACCOUNT, chosen
+ * when one is added (`useAddAccount`), never here. When the project already
+ * has a profile for this app and surface, Install reuses it.
+ */
+export declare function runInstall(deps: InstallDeps, input: {
+    projectId: string;
+    target: InstallTarget;
+    connectors: readonly Pick<AdminConnector, 'slug' | 'provider' | 'name'>[];
+}): Promise<InstallResult>;

package/dist/customize/connectors/install/install.js

@@ -0,0 +1,97 @@
+import { buildDiscoverConnectorDraft, buildEasyConnectConnectorDraft, connectorSyncErrorForSlug, isAuthChallenge, normalizeConnectorConnectionSlug, proposeConnectorConnectionName, proposeConnectorConnectionSlug, } from '../../sections/connector-connection-form.js';
+export function discoverInstallTarget(appName, variant) {
+    const template = variant.template;
+    return {
+        appName,
+        provider: template.provider,
+        managed: false,
+        needsCredential: Boolean(template.auth) && template.auth?.type !== 'none',
+        buildDraft: (input) => buildDiscoverConnectorDraft(template, input),
+    };
+}
+export function easyConnectInstallTarget(app) {
+    return {
+        appName: app.name,
+        provider: app.provider ?? 'pipedream',
+        managed: true,
+        needsCredential: false,
+        buildDraft: (input) => buildEasyConnectConnectorDraft(app, input),
+    };
+}
+/**
+ * Did Install create this connector for this app and surface?
+ *
+ * STRICT, because the answer decides where a new account is authorized. Three
+ * things must hold:
+ * - the provider matches;
+ * - the slug is exactly what `proposeConnectorConnectionSlug` builds for the
+ *   app's name, `<normalized name>-<6 base36>`, never a prefix;
+ * - the display name is what `proposeConnectorConnectionName` gives: the app's
+ *   name, or `<App> <n>` with n an integer of 2 or more. A six-character word
+ *   reads as a random suffix (`notion-search`, `google-sheets`), and the name
+ *   is what tells those apart.
+ *
+ * A renamed connector is therefore not reused. That miss costs a second
+ * connector, which is the cheap failure. A false hit would authorize the
+ * wrong app.
+ */
+export function connectorInstalledFrom(connector, appName, provider) {
+    if (connector.provider !== provider)
+        return false;
+    const base = normalizeConnectorConnectionSlug(appName).replace(/[-_]+$/g, '');
+    if (!base || !connector.slug.startsWith(`${base}-`))
+        return false;
+    if (!/^[a-z0-9]{6}$/.test(connector.slug.slice(base.length + 1)))
+        return false;
+    const app = appName.trim().toLowerCase();
+    const name = (connector.name ?? '').trim().toLowerCase();
+    if (!app || !name)
+        return false;
+    if (name === app)
+        return true;
+    if (!name.startsWith(`${app} `))
+        return false;
+    const ordinal = name.slice(app.length + 1);
+    return /^[1-9][0-9]*$/.test(ordinal) && Number(ordinal) >= 2;
+}
+/**
+ * The name a new account gets: the app's name, then `<name> 2`, `<name> 3`.
+ * `POST /connections` with a label an account of the same owner already uses
+ * updates that account instead of adding one, so the label must be free.
+ */
+export function proposeAccountLabel(appName, taken) {
+    const used = new Set(taken.map((label) => label.trim().toLowerCase()));
+    const name = appName.trim();
+    if (!used.has(name.toLowerCase()))
+        return name;
+    for (let n = 2;; n += 1) {
+        const candidate = `${name} ${n}`;
+        if (!used.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}
+/**
+ * Install = add the connector PROFILE to the project, nothing more.
+ *
+ * A profile is always the project's: the app, its config and its rules (a
+ * `kortix.yaml` entry). Who may use it is a property of each ACCOUNT, chosen
+ * when one is added (`useAddAccount`), never here. When the project already
+ * has a profile for this app and surface, Install reuses it.
+ */
+export async function runInstall(deps, input) {
+    const { projectId, target, connectors } = input;
+    const existing = connectors.find((connector) => connectorInstalledFrom(connector, target.appName, target.provider));
+    if (existing)
+        return { status: 'installed', slug: existing.slug };
+    const slugs = connectors.map((connector) => connector.slug);
+    const slug = proposeConnectorConnectionSlug(target.appName, slugs, deps.random);
+    const name = proposeConnectorConnectionName(target.appName, slugs);
+    const result = await deps.createConnector(projectId, target.buildDraft({ slug, name }));
+    const syncError = connectorSyncErrorForSlug(result, slug);
+    // An MCP server that signs in with OAuth answers its first tools/list with
+    // 401 or 403: that is the sign-in still to do, not a broken install.
+    if (syncError && !(target.provider === 'mcp' && isAuthChallenge(syncError))) {
+        return { status: 'sync_failed', slug, name, error: syncError };
+    }
+    return { status: 'installed', slug };
+}

package/dist/customize/connectors/install/mcp-first.d.ts

@@ -0,0 +1,15 @@
+import { type McpServerSignInCheck } from '@kortix/sdk';
+/** An app's own hosted MCP server, as the Install dialog opens it. */
+export interface McpServerApp {
+    name: string;
+    url: string;
+}
+/**
+ * The app's own MCP server, when Install should connect through it: the app
+ * has one, and the user's consent is the whole sign-in (OAuth with dynamic
+ * client registration). Otherwise null, and Install keeps the managed app.
+ */
+export declare function mcpServerFor(projectId: string, app: {
+    name: string;
+    directMcpUrl?: string | null;
+}, check?: (projectId: string, url: string) => Promise<McpServerSignInCheck>): Promise<McpServerApp | null>;

package/dist/customize/connectors/install/mcp-first.js

@@ -0,0 +1,17 @@
+import { checkMcpServerSignIn } from '@kortix/sdk';
+/**
+ * The app's own MCP server, when Install should connect through it: the app
+ * has one, and the user's consent is the whole sign-in (OAuth with dynamic
+ * client registration). Otherwise null, and Install keeps the managed app.
+ */
+export async function mcpServerFor(projectId, app, check = checkMcpServerSignIn) {
+    if (!app.directMcpUrl)
+        return null;
+    try {
+        const result = await check(projectId, app.directMcpUrl);
+        return result.one_click ? { name: app.name, url: app.directMcpUrl } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/customize/connectors/install/pick-surface.d.ts

@@ -0,0 +1,22 @@
+import type { DiscoverConnectorTemplate, DiscoverConnectorVariant } from '@kortix/sdk';
+/** A published surface that carries the template Install builds a connector from. */
+export interface InstallableVariant {
+    id: string;
+    kind: DiscoverConnectorVariant['kind'];
+    name: string;
+    template: DiscoverConnectorTemplate;
+}
+/** The surfaces Install can use: MCP first, the rest in catalogue order. */
+export declare function installableVariants(variants: readonly DiscoverConnectorVariant[]): InstallableVariant[];
+/**
+ * The name Install gives the connector of one surface, and looks an installed
+ * one up by. Only the primary surface (index 0 of `installableVariants`, the
+ * one `pickSurface` returns) takes the app's name. Every other surface takes
+ * its own name, qualified by the app: surface names are not unique across apps
+ * (the catalogue falls back to `Surface <n>`), and an unqualified one would
+ * let two apps share a connector. A surface with no name of its own, or named
+ * exactly as the app, is numbered, so it never takes the primary's name.
+ */
+export declare function surfaceInstallName(appName: string, variant: InstallableVariant, index: number): string;
+/** The surface Install uses without asking. */
+export declare function pickSurface(variants: readonly DiscoverConnectorVariant[]): InstallableVariant | null;

package/dist/customize/connectors/install/pick-surface.js

@@ -0,0 +1,32 @@
+/** The surfaces Install can use: MCP first, the rest in catalogue order. */
+export function installableVariants(variants) {
+    const usable = variants.flatMap((variant) => variant.connector
+        ? [{ id: variant.id, kind: variant.kind, name: variant.name, template: variant.connector }]
+        : []);
+    return [
+        ...usable.filter((variant) => variant.kind === 'mcp'),
+        ...usable.filter((variant) => variant.kind !== 'mcp'),
+    ];
+}
+/**
+ * The name Install gives the connector of one surface, and looks an installed
+ * one up by. Only the primary surface (index 0 of `installableVariants`, the
+ * one `pickSurface` returns) takes the app's name. Every other surface takes
+ * its own name, qualified by the app: surface names are not unique across apps
+ * (the catalogue falls back to `Surface <n>`), and an unqualified one would
+ * let two apps share a connector. A surface with no name of its own, or named
+ * exactly as the app, is numbered, so it never takes the primary's name.
+ */
+export function surfaceInstallName(appName, variant, index) {
+    if (index === 0)
+        return appName;
+    const app = appName.trim();
+    const name = variant.name.trim();
+    if (!name || name.toLowerCase() === app.toLowerCase())
+        return `${appName} ${index + 1}`;
+    return name.toLowerCase().startsWith(app.toLowerCase()) ? name : `${appName} ${name}`;
+}
+/** The surface Install uses without asking. */
+export function pickSurface(variants) {
+    return installableVariants(variants)[0] ?? null;
+}

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

@@ -0,0 +1,28 @@
+import { type AdminConnector } from '@kortix/sdk';
+import type { CatalogEntry } from '../catalog/catalog-entry.js';
+import { type AppRef } from '../connector-routes.js';
+import { type InstallTarget } from './install.js';
+import { type McpServerApp } from './mcp-first.js';
+/**
+ * Install one app: add its connector profile to the project, then open the
+ * connector page with "Add account" showing. Who may use an account is chosen
+ * there, per account; the profile itself is always the project's. When the
+ * first sync fails, the page opens on its error and Retry instead.
+ *
+ * A managed app whose own MCP server signs in with one click goes to
+ * `onMcpServer` instead: the MCP dialog connects it in one step.
+ */
+export declare function useInstall(projectId: string, options?: {
+    onMcpServer?: (server: McpServerApp) => void;
+}): {
+    install: (target: InstallTarget, options: {
+        connectors: readonly AdminConnector[];
+        app: AppRef | null;
+        /** Open "Add account" on the connector page. False for a server with
+         *  nothing to sign in to: its project account is the connection. */
+        addAccount?: boolean;
+    }) => void;
+    installEntry: (entry: CatalogEntry, connectors: readonly AdminConnector[]) => void;
+    pendingKey: string | null;
+    setPendingKey: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+};

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

@@ -0,0 +1,126 @@
+'use client';
+import { invalidateConnections } from '../invalidate-connections.js';
+import { checkMcpServerSignIn, createConnector, getDiscoverConnector, } from '@kortix/sdk';
+import { useQueryClient } from '@tanstack/react-query';
+import { useUiRouter } from '../../../providers/ui-provider.js';
+import { useCallback, useState } from 'react';
+import { errorToast, successToast, warningToast } from '../../../primitives/toast.js';
+import { appHref, appRefFromEntry, connectorHref, } from '../connector-routes.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { discoverInstallTarget, easyConnectInstallTarget, runInstall, } from './install.js';
+import { mcpServerFor } from './mcp-first.js';
+import { pickSurface } from './pick-surface.js';
+const sdkInstallDeps = { createConnector };
+/**
+ * Install one app: add its connector profile to the project, then open the
+ * connector page with "Add account" showing. Who may use an account is chosen
+ * there, per account; the profile itself is always the project's. When the
+ * first sync fails, the page opens on its error and Retry instead.
+ *
+ * A managed app whose own MCP server signs in with one click goes to
+ * `onMcpServer` instead: the MCP dialog connects it in one step.
+ */
+export function useInstall(projectId, options = {}) {
+    const { onMcpServer } = options;
+    const t = useTranslations('connectorPages');
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const router = useUiRouter();
+    const queryClient = useQueryClient();
+    const [pendingKey, setPendingKey] = useState(null);
+    const install = useCallback((target, options) => {
+        /** Settles when every invalidated query has refetched. Never rejects. */
+        const refresh = () => invalidateConnections(queryClient, projectId);
+        setPendingKey(options.app?.slug ?? target.appName);
+        void runInstall(sdkInstallDeps, { projectId, target, connectors: options.connectors })
+            .then(async (result) => {
+            // Before the navigation: the connector page reads the fresh list.
+            await refresh();
+            // The profile exists either way, so land on its page. A failed sync
+            // shows its reason and Retry there instead of opening Add account.
+            const failed = result.status === 'sync_failed';
+            if (failed) {
+                warningToast(t('installedSyncFailed', { name: result.name, error: result.error }));
+            }
+            else {
+                successToast(t('installed', { name: target.appName }));
+            }
+            router.push(connectorHref(projectId, result.slug, {
+                app: options.app,
+                addAccount: !failed && options.addAccount !== false,
+            }));
+        })
+            .catch(async (error) => {
+            // A failure can land after the connector was created. A retry must
+            // see it, or it creates a second one: Install stays pending until
+            // the refreshed list has arrived.
+            errorToast(error.message || tI18nComplete.raw('texta34a2714da91'));
+            await refresh();
+        })
+            .finally(() => setPendingKey(null));
+    }, [projectId, queryClient, router, t, tI18nComplete]);
+    /** Install straight from a catalogue card. */
+    const installEntry = useCallback((entry, connectors) => {
+        const app = appRefFromEntry(entry);
+        if (entry.source === 'easy-connect') {
+            if (!onMcpServer || !entry.app.directMcpUrl) {
+                install(easyConnectInstallTarget(entry.app), { connectors, app });
+                return;
+            }
+            setPendingKey(app?.slug ?? entry.app.name);
+            void mcpServerFor(projectId, entry.app).then((server) => {
+                if (server) {
+                    setPendingKey(null);
+                    onMcpServer(server);
+                }
+                else {
+                    install(easyConnectInstallTarget(entry.app), { connectors, app });
+                }
+            });
+            return;
+        }
+        if (entry.source !== 'discover' || !app)
+            return;
+        // A Discover card does not carry its surfaces; the detail does. Direct
+        // providers open no provider window, so this fetch costs no click.
+        setPendingKey(app.slug);
+        void queryClient
+            .fetchQuery({
+            queryKey: ['discover-connector-detail', projectId, entry.connector.id],
+            queryFn: () => getDiscoverConnector(projectId, entry.connector.id),
+            staleTime: 15 * 60_000,
+        })
+            .then(async (detail) => {
+            const variant = pickSurface(detail.variants);
+            if (!variant) {
+                // Nothing installable from here: the app page shows its surfaces.
+                setPendingKey(null);
+                router.push(appHref(projectId, app));
+                return;
+            }
+            const mcpUrl = variant.kind === 'mcp' ? variant.template.url : undefined;
+            // A Kortix catalogue app (connectors_v2) is its vendor's MCP server:
+            // a one-click sign-in opens the one-step MCP dialog, a public server
+            // installs with no account to add, anything else installs as before.
+            if (entry.connector.feeds.includes('kortix') && mcpUrl && onMcpServer) {
+                const check = await checkMcpServerSignIn(projectId, mcpUrl).catch(() => null);
+                if (check?.one_click) {
+                    setPendingKey(null);
+                    onMcpServer({ name: entry.name, url: mcpUrl });
+                    return;
+                }
+                install(discoverInstallTarget(entry.name, variant), {
+                    connectors,
+                    app,
+                    addAccount: check?.requires_sign_in !== false,
+                });
+                return;
+            }
+            install(discoverInstallTarget(entry.name, variant), { connectors, app });
+        })
+            .catch((error) => {
+            setPendingKey(null);
+            errorToast(error.message || tI18nComplete.raw('texta34a2714da91'));
+        });
+    }, [install, onMcpServer, projectId, queryClient, router, tI18nComplete]);
+    return { install, installEntry, pendingKey, setPendingKey };
+}

package/dist/customize/connectors/invalidate-connections.d.ts

@@ -0,0 +1,2 @@
+import type { QueryClient } from '@tanstack/react-query';
+export declare function invalidateConnections(client: QueryClient, projectId: string): Promise<(void | undefined)[]>;

package/dist/customize/connectors/invalidate-connections.js

@@ -0,0 +1,4 @@
+import { connectorConnectionQueryKeys } from '../sections/connector-connection-form.js';
+export function invalidateConnections(client, projectId) {
+    return Promise.all(connectorConnectionQueryKeys(projectId).map((queryKey) => client.invalidateQueries({ queryKey }).catch(() => undefined)));
+}

package/dist/customize/connectors/provider-label.d.ts

@@ -0,0 +1,20 @@
+import type { AdminConnector } from '@kortix/sdk';
+/**
+ * Forward-facing provider label — "App" for the 1-click (Pipedream) connectors.
+ *
+ * Lives here, in the connectors feature folder, rather than in
+ * `customize/sections/connectors-view.tsx` where it started. That module is
+ * 5,219 lines and 50 components; exporting this plain function beside them took
+ * the whole file off React Fast Refresh's hot path (every edit = full page
+ * reload), and importing this six-line switch from it dragged the entire module
+ * — plus `@pipedream/sdk/browser`, `HighlightedCode`, `PoliciesPanel` — into
+ * the `/projects/[id]/connectors` route chunk.
+ *
+ * The legacy Customize surface imports it back from here. That direction is
+ * deliberate: when `connectors-view.tsx` is retired, this module does not move.
+ */
+export declare function providerLabel(p: AdminConnector['provider']): string;
+/** Providers whose accounts are authorized through the normalized Connect Link gateway. */
+export declare function isManagedConnectorProvider(p: AdminConnector['provider']): boolean;
+/** Whether a Composio connection has completed provider authorization. */
+export declare function composioConnectionIsAuthorized(metadata: Record<string, unknown> | null | undefined): boolean;

package/dist/customize/connectors/provider-label.js

@@ -0,0 +1,41 @@
+/**
+ * Forward-facing provider label — "App" for the 1-click (Pipedream) connectors.
+ *
+ * Lives here, in the connectors feature folder, rather than in
+ * `customize/sections/connectors-view.tsx` where it started. That module is
+ * 5,219 lines and 50 components; exporting this plain function beside them took
+ * the whole file off React Fast Refresh's hot path (every edit = full page
+ * reload), and importing this six-line switch from it dragged the entire module
+ * — plus `@pipedream/sdk/browser`, `HighlightedCode`, `PoliciesPanel` — into
+ * the `/projects/[id]/connectors` route chunk.
+ *
+ * The legacy Customize surface imports it back from here. That direction is
+ * deliberate: when `connectors-view.tsx` is retired, this module does not move.
+ */
+export function providerLabel(p) {
+    if (isManagedConnectorProvider(p))
+        return 'App';
+    if (p === 'channel')
+        return 'Channel';
+    if (p === 'computer')
+        return 'Computer';
+    if (p === 'postman')
+        return 'Postman';
+    return p.toUpperCase();
+}
+/** Providers whose accounts are authorized through the normalized Connect Link gateway. */
+export function isManagedConnectorProvider(p) {
+    return p === 'composio' || p === 'pipedream';
+}
+/** Whether a Composio connection has completed provider authorization. */
+export function composioConnectionIsAuthorized(metadata) {
+    if (metadata?.provider !== 'composio')
+        return false;
+    const sessionId = metadata.session_id;
+    if (typeof sessionId !== 'string' || sessionId.trim().length === 0)
+        return false;
+    if (metadata.is_no_auth === true)
+        return true;
+    const accountId = metadata.connected_account_id;
+    return typeof accountId === 'string' && accountId.trim().length > 0;
+}

package/dist/customize/connectors/tools/pattern-rule-draft.d.ts

@@ -0,0 +1,40 @@
+import type { ConnectorPolicyAction, ConnectorPolicyRule } from '@kortix/sdk';
+/** One editable row in the Advanced editor's pattern-rule list. `id` is a
+ *  render key only — it never reaches the wire and never enters a signature. */
+export interface PatternDraftRow {
+    id: string;
+    match: string;
+    action: ConnectorPolicyAction;
+}
+/**
+ * A content signature for a set of pattern rules, immune to the one reordering
+ * the write path performs.
+ *
+ * Two callers depend on this in `connector-tools.tsx`: the reseed guard, which
+ * refuses to rebuild the draft while the server's pattern set is unchanged, and
+ * the dirty check behind Discard/Save.
+ *
+ * `orderPolicyRules` is applied FIRST, and that is the whole point. The
+ * optimistic cache write puts `orderPolicyRules(write.rules)` into
+ * `['connector-policies', …]` on every per-tool click, which hoists every
+ * non-pattern rule ahead of every pattern rule. A signature that encoded raw
+ * array position therefore changed when nothing about the rules did:
+ *
+ *   server order   [{delete_*}, {retired_tool}]   -> "delete_*=…\nretired_tool=…"
+ *   after a click  [{retired_tool}, {delete_*}]   -> "retired_tool=…\ndelete_*=…"
+ *
+ * The reseed guard read that as "the server's pattern set changed", rebuilt the
+ * draft, and threw away whatever the user had half-typed into a new row. Since
+ * `orderPolicyRules` is exactly the transformation being defended against,
+ * normalizing through it is immune by construction — and, unlike a plain sort,
+ * it still reports a genuine reorder WITHIN either class, which the engine
+ * resolves by authoring order and which the user can still cause by deleting a
+ * row and re-adding it.
+ */
+export declare function signPatternRules(rules: readonly ConnectorPolicyRule[]): string;
+/** The draft rows a rule set seeds, in the order the rules arrived. */
+export declare function seedPatternDraft(rules: readonly ConnectorPolicyRule[], nextId: () => string): PatternDraftRow[];
+/** The wire form of a draft: blank rows dropped, every match trimmed, `id`
+ *  gone. Shared by the dirty check and the save, so the two can never disagree
+ *  about what "unchanged" means. */
+export declare function draftToRules(draft: readonly PatternDraftRow[]): ConnectorPolicyRule[];

package/dist/customize/connectors/tools/pattern-rule-draft.js

@@ -0,0 +1,43 @@
+import { orderPolicyRules } from './tool-policy.js';
+/**
+ * A content signature for a set of pattern rules, immune to the one reordering
+ * the write path performs.
+ *
+ * Two callers depend on this in `connector-tools.tsx`: the reseed guard, which
+ * refuses to rebuild the draft while the server's pattern set is unchanged, and
+ * the dirty check behind Discard/Save.
+ *
+ * `orderPolicyRules` is applied FIRST, and that is the whole point. The
+ * optimistic cache write puts `orderPolicyRules(write.rules)` into
+ * `['connector-policies', …]` on every per-tool click, which hoists every
+ * non-pattern rule ahead of every pattern rule. A signature that encoded raw
+ * array position therefore changed when nothing about the rules did:
+ *
+ *   server order   [{delete_*}, {retired_tool}]   -> "delete_*=…\nretired_tool=…"
+ *   after a click  [{retired_tool}, {delete_*}]   -> "retired_tool=…\ndelete_*=…"
+ *
+ * The reseed guard read that as "the server's pattern set changed", rebuilt the
+ * draft, and threw away whatever the user had half-typed into a new row. Since
+ * `orderPolicyRules` is exactly the transformation being defended against,
+ * normalizing through it is immune by construction — and, unlike a plain sort,
+ * it still reports a genuine reorder WITHIN either class, which the engine
+ * resolves by authoring order and which the user can still cause by deleting a
+ * row and re-adding it.
+ */
+export function signPatternRules(rules) {
+    return orderPolicyRules(rules)
+        .map((rule) => `${rule.match}=${rule.action}`)
+        .join('\n');
+}
+/** The draft rows a rule set seeds, in the order the rules arrived. */
+export function seedPatternDraft(rules, nextId) {
+    return rules.map((rule) => ({ id: nextId(), match: rule.match, action: rule.action }));
+}
+/** The wire form of a draft: blank rows dropped, every match trimmed, `id`
+ *  gone. Shared by the dirty check and the save, so the two can never disagree
+ *  about what "unchanged" means. */
+export function draftToRules(draft) {
+    return draft
+        .filter((row) => row.match.trim())
+        .map((row) => ({ match: row.match.trim(), action: row.action }));
+}

package/dist/customize/connectors/tools/tool-groups.d.ts

@@ -0,0 +1,46 @@
+import type { UiTranslator } from '../../../i18n/index.js';
+import type { ConnectorAction } from '@kortix/sdk';
+export interface ToolGroup {
+    key: 'read' | 'write';
+    label: string;
+    actions: ConnectorAction[];
+}
+/**
+ * Two buckets, because that is the only distinction a non-technical reader
+ * needs before granting access: can this look at my data, or change it.
+ * `destructive` folds into writes — a delete is a write with worse consequences,
+ * and a third bucket would just make the safe/unsafe line harder to see.
+ *
+ * An empty bucket is omitted rather than rendered as a heading over nothing.
+ * Input order is kept inside each bucket: that is the order the connector
+ * reports its tools in, which is the order its own docs use.
+ */
+export declare function groupToolsByRisk(actions: readonly ConnectorAction[], tI18nComplete: UiTranslator): ToolGroup[];
+export interface ToolRowText {
+    /** The row's heading. */
+    title: string;
+    /** The tool path, or `null` when the title already IS the path. */
+    path: string | null;
+    /** The description, or `null` when it only repeats the title. */
+    description: string | null;
+}
+/**
+ * What one row prints, with nothing said twice.
+ *
+ * An OpenAPI connector commonly derives both `name` and `description` from the
+ * same `summary` — the live `petstore` fixture does for all 19 of its tools —
+ * so a naive row renders "Deletes a pet." over "Deletes a pet." The path is
+ * dropped the same way when the connector never gave the tool a real name.
+ */
+export declare function toolRowText(action: ConnectorAction): ToolRowText;
+/**
+ * Narrow a tool list by a free-text query. A connector with 60 tools is
+ * unusable without one.
+ *
+ * Matches the path, the display name and the description, because a reader
+ * looking for "the one that sends mail" knows the words in the description
+ * long before they know `messages.send`. An all-whitespace query is not a
+ * query — returning nothing for a stray space would read as "this connector
+ * has no tools", which is a different and much worse claim.
+ */
+export declare function filterActions(actions: readonly ConnectorAction[], query: string): ConnectorAction[];