1485 lines · 53.8 KB · TypeScript
RawDownload
import { useId, useMemo, useState } from "react";import { Link, useNavigate } from "@tanstack/react-router";import { useAtomSet, useAtomValue } from "@effect/atom-react";import * as Atom from "effect/unstable/reactivity/Atom";import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";import { ArrowLeftIcon, BoxIcon, PlugIcon, PlusIcon, SearchIcon, Trash2Icon } from "lucide-react";import {  createPluginAtomClient,  useIntegrationPlugins,  type IntegrationPlugin,  type PluginPageProps,} from "@executor-js/sdk/client";import {  matchPattern,  type EffectivePolicy,  type Integration,  type Owner,  type ToolAddress,  type ToolPolicyAction,} from "@executor-js/sdk/shared";import { integrationsOptimisticAtom, toolsAllAtom } from "@executor-js/react/api/atoms";import { ReactivityKey } from "@executor-js/react/api/reactivity-keys";import { useOrganizationSlug } from "@executor-js/react/api/organization-context";import {  getExecutorApiBaseUrl,  getExecutorOrganizationHeaders,  getExecutorServerAuthorizationHeader,} from "@executor-js/react/api/server-connection";import { ownerLabel, useOwnerDisplay } from "@executor-js/react/api/owner-display";import { Badge } from "@executor-js/react/components/badge";import { Button } from "@executor-js/react/components/button";import { CopyButton } from "@executor-js/react/components/copy-button";import {  AlertDialog,  AlertDialogAction,  AlertDialogCancel,  AlertDialogContent,  AlertDialogDescription,  AlertDialogFooter,  AlertDialogHeader,  AlertDialogTitle,  AlertDialogTrigger,} from "@executor-js/react/components/alert-dialog";import {  IntegrationFavicon,  integrationPresetIconUrl,} from "@executor-js/react/components/integration-favicon";import {  Dialog,  DialogContent,  DialogDescription,  DialogFooter,  DialogHeader,  DialogTitle,} from "@executor-js/react/components/dialog";import { Input } from "@executor-js/react/components/input";import { Label } from "@executor-js/react/components/label";import { Skeleton } from "@executor-js/react/components/skeleton";import { ToolDetail, ToolDetailEmpty } from "@executor-js/react/components/tool-detail";import { ToolTree, type ToolSummary } from "@executor-js/react/components/tool-tree";import { cn } from "@executor-js/react/lib/utils"; import {  ToolkitsApi,  type ToolkitConnectionResponse,  type ToolkitPolicyResponse,  type ToolkitResponse,} from "./shared"; const ToolkitsClient = createPluginAtomClient(ToolkitsApi, {  baseUrl: getExecutorApiBaseUrl,  authorizationHeader: getExecutorServerAuthorizationHeader,  headers: getExecutorOrganizationHeaders,}); const toolkitWriteKeys = [  ReactivityKey.connections,  ReactivityKey.policies,  ReactivityKey.tools,] as const; const toolkitsAtom = ToolkitsClient.query("toolkits", "list", {  timeToLive: "30 seconds",  reactivityKeys: [ReactivityKey.policies],}); const toolkitPoliciesAtom = Atom.family((toolkitId: string) =>  ToolkitsClient.query("toolkits", "listPolicies", {    params: { toolkitId },    timeToLive: "30 seconds",    reactivityKeys: [ReactivityKey.policies],  }),); const toolkitConnectionsAtom = Atom.family((toolkitId: string) =>  ToolkitsClient.query("toolkits", "listConnections", {    params: { toolkitId },    timeToLive: "30 seconds",    reactivityKeys: [ReactivityKey.connections],  }),); const createToolkit = ToolkitsClient.mutation("toolkits", "create");const removeToolkit = ToolkitsClient.mutation("toolkits", "remove");const createToolkitPolicy = ToolkitsClient.mutation("toolkits", "createPolicy");const updateToolkitPolicy = ToolkitsClient.mutation("toolkits", "updatePolicy");const removeToolkitPolicy = ToolkitsClient.mutation("toolkits", "removePolicy");const createToolkitConnection = ToolkitsClient.mutation("toolkits", "createConnection");const removeToolkitConnection = ToolkitsClient.mutation("toolkits", "removeConnection"); type ToolRow = {  readonly address: ToolAddress;  readonly integration: string;  readonly owner?: Owner;  readonly connection?: string;  readonly name: string;  readonly description?: string;  readonly requiresApproval?: boolean;  readonly static?: boolean;}; const comparePolicy = (a: ToolkitPolicyResponse, b: ToolkitPolicyResponse): number => {  if (a.position < b.position) return -1;  if (a.position > b.position) return 1;  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;}; const pluginDefaultPolicy = (requiresApproval: boolean | undefined): EffectivePolicy =>  requiresApproval    ? { action: "require_approval", source: "plugin-default" }    : { action: "approve", source: "plugin-default" }; const isLegacyConnectionPolicy = (policy: ToolkitPolicyResponse): boolean => {  if (policy.action !== "approve") return false;  const parts = policy.pattern.split(".");  return parts.at(-1) === "*" && (parts.length === 3 || parts.length === 4);}; const resolveToolkitPolicy = (  matchId: string,  policies: readonly ToolkitPolicyResponse[],  requiresApproval?: boolean,): EffectivePolicy => {  for (const policy of [...policies].sort(comparePolicy)) {    if (!matchPattern(policy.pattern, matchId)) continue;    return {      action: policy.action,      source: "user",      pattern: policy.pattern,      policyId: policy.id,    };  }  return pluginDefaultPolicy(requiresApproval);}; const toolMatchId = (tool: ToolRow): string =>  tool.static ? String(tool.address) : String(tool.address).replace(/^tools\./, ""); const toolCanAppearInToolkit = (toolkit: ToolkitResponse, tool: ToolRow): boolean =>  toolkit.owner === "user" || tool.static === true || tool.owner !== "user"; const toolkitUrlFor = (orgSlug: string | undefined, slug: string): string => {  const path = orgSlug ? `/${orgSlug}/mcp/toolkits/${slug}` : `/mcp/toolkits/${slug}`;  if (typeof window === "undefined") return path;  return `${window.location.origin}${path}`;}; const identityPattern = (displayPattern: string): string => displayPattern; const compareToolkitRows = (a: ToolkitResponse, b: ToolkitResponse): number => {  if (a.updatedAt !== b.updatedAt) return b.updatedAt - a.updatedAt;  return a.name.localeCompare(b.name);}; const toolkitByRouteSlug = (  toolkits: readonly ToolkitResponse[],  slug: string,): ToolkitResponse | null => {  const matches = toolkits.filter((toolkit) => toolkit.slug === slug);  return matches.find((toolkit) => toolkit.owner === "org") ?? matches[0] ?? null;}; const toolkitCardStyle = { minHeight: "9rem" };const toolkitShelfStyle = { minHeight: "28.5rem" };const toolkitGridContainerStyle = { maxWidth: "80rem" };const toolkitToolTreeStyle = { width: "24rem" }; const neutralToolkitIconClass = "border-border/70 bg-muted/30 text-muted-foreground"; type ToolkitConnectionGroup = {  readonly id: string;  readonly owner: Owner;  readonly integration: string;  readonly connection: string;  readonly patterns: readonly string[];  readonly tools: readonly ToolRow[];}; type IntegrationMeta = {  readonly name: string;  readonly sourceId: string;  readonly icon?: string | null;  readonly url?: string;}; const toolOwner = (tool: ToolRow): Owner => (tool.static ? "org" : (tool.owner ?? "org")); const toolConnectionName = (tool: ToolRow): string => {  if (tool.connection && tool.connection.length > 0) return tool.connection;  return tool.static ? "built-in" : "default";}; const policyPrefixForTool = (tool: ToolRow): string => {  const matchId = toolMatchId(tool);  const integration = String(tool.integration);  if (tool.connection && tool.connection.length > 0) {    const connection = String(tool.connection);    if (tool.owner) {      const ownerConnectionPrefix = `${integration}.${tool.owner}.${connection}`;      if (matchId === ownerConnectionPrefix || matchId.startsWith(`${ownerConnectionPrefix}.`)) {        return ownerConnectionPrefix;      }    }    const connectionPrefix = `${integration}.${connection}`;    if (matchId === connectionPrefix || matchId.startsWith(`${connectionPrefix}.`)) {      return connectionPrefix;    }  }  const name = String(tool.name);  if (name.length > 0 && matchId.endsWith(`.${name}`)) {    return matchId.slice(0, -name.length - 1);  }  const segments = matchId.split(".");  return segments.length > 1 ? segments.slice(0, -1).join(".") : matchId;}; const connectionPatternForTool = (tool: ToolRow): string => `${policyPrefixForTool(tool)}.*`; const compareConnectionGroups = (a: ToolkitConnectionGroup, b: ToolkitConnectionGroup): number => {  const ownerRank = (owner: Owner) => (owner === "org" ? 0 : 1);  return (    ownerRank(a.owner) - ownerRank(b.owner) ||    a.integration.localeCompare(b.integration) ||    a.connection.localeCompare(b.connection) ||    a.id.localeCompare(b.id)  );}; const patternSubsumes = (candidate: string, covered: string): boolean => {  if (candidate === covered) return true;  if (!candidate.endsWith(".*")) return false;  const prefix = candidate.slice(0, -1);  return covered.startsWith(prefix);}; const reducePolicyPatterns = (patterns: readonly string[]): readonly string[] => {  const unique = [...new Set(patterns)].sort((a, b) => a.localeCompare(b));  return unique.filter(    (pattern) =>      !unique.some((candidate) => candidate !== pattern && patternSubsumes(candidate, pattern)),  );}; const buildConnectionGroups = (tools: readonly ToolRow[]): readonly ToolkitConnectionGroup[] => {  const groups = new Map<string, ToolkitConnectionGroup & { tools: ToolRow[] }>();  for (const tool of tools) {    const owner = toolOwner(tool);    const key = `${owner}:${tool.integration}:${toolConnectionName(tool)}`;    const existing = groups.get(key);    if (existing) {      existing.tools.push(tool);      continue;    }    groups.set(key, {      id: key,      owner,      integration: String(tool.integration),      connection: toolConnectionName(tool),      patterns: [],      tools: [tool],    });  }  return [...groups.values()]    .map((group) => {      const sortedTools = [...group.tools].sort(compareTools);      return {        ...group,        patterns: reducePolicyPatterns(sortedTools.map(connectionPatternForTool)),        tools: sortedTools,      };    })    .sort(compareConnectionGroups);}; const compareTools = (a: ToolRow, b: ToolRow): number =>  String(a.name).localeCompare(String(b.name)) || toolMatchId(a).localeCompare(toolMatchId(b)); const connectionTitle = (group: ToolkitConnectionGroup): string =>  `${ownerLabel(group.owner)} ${group.integration} / ${group.connection}`; const connectionTitleForHost = (group: ToolkitConnectionGroup, showOwnerLabels: boolean): string =>  showOwnerLabels ? connectionTitle(group) : `${group.integration} / ${group.connection}`; const connectionDisplayTitle = (group: ToolkitConnectionGroup, meta: IntegrationMeta): string =>  group.connection === "built-in" || group.connection === "default" ? meta.name : group.connection; const connectionDisplaySubtitle = (group: ToolkitConnectionGroup, meta: IntegrationMeta): string =>  group.connection === "built-in" || group.connection === "default"    ? `${group.tools.length} ${group.tools.length === 1 ? "tool" : "tools"}`    : `${meta.name} · ${group.tools.length} ${group.tools.length === 1 ? "tool" : "tools"}`; const connectionDisplaySubtitleForHost = (  group: ToolkitConnectionGroup,  meta: IntegrationMeta,  showOwnerLabels: boolean,): string => {  const subtitle = connectionDisplaySubtitle(group, meta);  return showOwnerLabels ? `${ownerLabel(group.owner)} · ${subtitle}` : subtitle;}; const integrationMetaFor = (  group: ToolkitConnectionGroup,  integrations: readonly Integration[],  integrationPlugins: readonly IntegrationPlugin[],): IntegrationMeta => {  const integration = integrations.find((row) => String(row.slug) === group.integration);  const fallbackName = group.integration    .replace(/[_-]/g, " ")    .replace(/\b\w/g, (character) => character.toUpperCase());  const source = {    id: group.integration,    kind: integration?.kind ?? group.integration,    name: integration?.name ?? fallbackName,    url: integration?.displayUrl,  };  return {    name: source.name,    sourceId: group.integration,    icon: integrationPresetIconUrl(source, integrationPlugins),    ...(source.url ? { url: source.url } : {}),  };}; type ConfiguredConnectionView = {  readonly id: string;  readonly title: string;  readonly subtitle: string;  readonly pattern: string;  readonly sourceId: string;  readonly icon?: string | null;  readonly url?: string;}; const configuredConnectionViews = (  connections: readonly ToolkitConnectionResponse[],  connectionGroups: readonly ToolkitConnectionGroup[],  integrations: readonly Integration[],  integrationPlugins: readonly IntegrationPlugin[],  showOwnerLabels: boolean,): readonly ConfiguredConnectionView[] =>  connections.map((connection) => {    const group = connectionGroups.find((candidate) =>      candidate.patterns.includes(connection.pattern),    );    if (!group) {      return {        id: connection.id,        title: connection.pattern,        subtitle: "Configured pattern",        pattern: connection.pattern,        sourceId: connection.pattern.split(".")[0] ?? "toolkit",      };    }    const meta = integrationMetaFor(group, integrations, integrationPlugins);    return {      id: connection.id,      title: connectionDisplayTitle(group, meta),      subtitle: connectionDisplaySubtitleForHost(group, meta, showOwnerLabels),      pattern: connection.pattern,      sourceId: meta.sourceId,      icon: meta.icon,      ...(meta.url ? { url: meta.url } : {}),    };  }); const legacyConnectionPolicyIds = (  policies: readonly ToolkitPolicyResponse[],  connectionGroups: readonly ToolkitConnectionGroup[],  connections: readonly ToolkitConnectionResponse[],): ReadonlySet<string> => {  const persistedPatterns = new Set(connections.map((connection) => connection.pattern));  const connectionPatterns = new Set(connectionGroups.flatMap((group) => group.patterns));  return new Set(    policies      .filter(        (policy) =>          isLegacyConnectionPolicy(policy) &&          connectionPatterns.has(policy.pattern) &&          !persistedPatterns.has(policy.pattern),      )      .map((policy) => policy.id),  );}; const configuredConnectionPatterns = (  connections: readonly ToolkitConnectionResponse[],  policies: readonly ToolkitPolicyResponse[],  legacyPolicyIds: ReadonlySet<string>,): ReadonlySet<string> =>  new Set([    ...connections.map((connection) => connection.pattern),    ...policies.filter((policy) => legacyPolicyIds.has(policy.id)).map((policy) => policy.pattern),  ]); function ToolkitConnectionIconStack(props: { connections: readonly ConfiguredConnectionView[] }) {  const visibleConnections = props.connections.slice(0, 3);  if (visibleConnections.length === 0) {    return (      <div        className={cn(          "flex size-9 shrink-0 items-center justify-center rounded-md border",          neutralToolkitIconClass,        )}      >        <BoxIcon className="size-4" />      </div>    );  }   return (    <div className="flex size-9 shrink-0 items-center justify-center rounded-md border border-border/70 bg-muted/20">      <div className="flex -space-x-2">        {visibleConnections.map((connection) => (          <span            key={connection.id}            className="flex size-5 items-center justify-center rounded-sm border border-background bg-card shadow-xs"          >            <IntegrationFavicon              icon={connection.icon}              sourceId={connection.sourceId}              url={connection.url}              size={14}            />          </span>        ))}      </div>    </div>  );} const connectionCountLabel = (count: number): string =>  count === 0 ? "No connections" : `${count} ${count === 1 ? "connection" : "connections"}`; function ToolkitTile(props: { showOwnerLabels: boolean; toolkit: ToolkitResponse }) {  const toolkit = props.toolkit;  const tools = useAtomValue(toolsAllAtom);  const integrations = useAtomValue(integrationsOptimisticAtom);  const connections = useAtomValue(toolkitConnectionsAtom(toolkit.id));  const integrationPlugins = useIntegrationPlugins();  const visibleTools = useMemo(    () =>      AsyncResult.isSuccess(tools)        ? (tools.value as readonly ToolRow[]).filter((tool) =>            toolCanAppearInToolkit(toolkit, tool),          )        : [],    [toolkit, tools],  );  const connectionGroups = useMemo(() => buildConnectionGroups(visibleTools), [visibleTools]);  const connectionRows = AsyncResult.isSuccess(connections) ? connections.value.connections : [];  const integrationRows = AsyncResult.isSuccess(integrations)    ? (integrations.value as readonly Integration[])    : [];  const tileDataReady =    AsyncResult.isSuccess(connections) &&    AsyncResult.isSuccess(tools) &&    AsyncResult.isSuccess(integrations);  const configuredConnections = tileDataReady    ? configuredConnectionViews(        connectionRows,        connectionGroups,        integrationRows,        integrationPlugins,        props.showOwnerLabels,      )    : [];  return (    <Link      to="/{-$orgSlug}/toolkits/$toolkitSlug"      params={{ toolkitSlug: toolkit.slug }}      aria-label={`Open toolkit ${toolkit.name}`}      className="group flex min-h-36 min-w-0 self-start flex-col justify-between rounded-md border border-border/70 bg-card p-3.5 text-left text-card-foreground shadow-xs transition-[border-color,background-color,box-shadow] hover:border-foreground/25 hover:bg-muted/20 hover:shadow-sm focus-visible:ring-[3px] focus-visible:ring-ring/30 focus-visible:outline-none"      style={toolkitCardStyle}    >      <div className="flex min-w-0 items-start gap-3">        {tileDataReady ? (          <ToolkitConnectionIconStack connections={configuredConnections} />        ) : (          <Skeleton className="size-9 shrink-0 rounded-md" />        )}

Lines 1–500 of 1485.