@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-NDQJZ7HF.js

@@ -0,0 +1,206 @@
+"use client";
+import {
+  hasWorkspacePermission,
+  isWorkspacePermissionDenied
+} from "./chunk-H2ALCTWC.js";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+import {
+  isTransientServiceFailure,
+  retryTransient
+} from "./chunk-5AIMVW6Y.js";
+
+// src/app/components/capabilities/use-capabilities-catalog.tsx
+import { useRef, useState } from "react";
+function emptyCatalogState(client, workspaceId, epoch, readAccess) {
+  return {
+    client,
+    workspaceId,
+    epoch,
+    items: [],
+    nativeConnectCatalog: { status: "loading", providers: [] },
+    connections: null,
+    connectionsLoadFailed: readAccess === false,
+    connectionsAccessDenied: readAccess === false,
+    apiIntegrationDefinitions: [],
+    apiIntegrationInstances: [],
+    socialConnections: [],
+    slackInstallationBindings: [],
+    memberIntegrationSetup: void 0,
+    loading: true,
+    loadError: null,
+    revision: 0
+  };
+}
+function useCapabilitiesCatalog(workspaceId) {
+  const context = useAppContext();
+  const client = context.client;
+  const readAccess = context.accessContext === null ? null : hasWorkspacePermission(context.accessContext, workspaceId, "connections:read");
+  const authorityKey = JSON.stringify(context.accessContext);
+  const scopeRef = useRef({ client, workspaceId, readAccess, authorityKey, epoch: 0 });
+  if (scopeRef.current.client !== client || scopeRef.current.workspaceId !== workspaceId || scopeRef.current.readAccess !== readAccess || scopeRef.current.authorityKey !== authorityKey) {
+    scopeRef.current = {
+      client,
+      workspaceId,
+      readAccess,
+      authorityKey,
+      epoch: scopeRef.current.epoch + 1
+    };
+  }
+  const epoch = scopeRef.current.epoch;
+  const [state, setState] = useState(
+    () => emptyCatalogState(client, workspaceId, epoch, readAccess)
+  );
+  const refreshRevision = useRef(0);
+  const connectionRevision = useRef(0);
+  const successfulConnectionRevision = useRef(0);
+  const deniedConnectionRevision = useRef(0);
+  const mutationAuthorityEpoch = useRef(0);
+  const callbackAuthorityEpoch = mutationAuthorityEpoch.current;
+  const isCurrentScope = () => scopeRef.current.epoch === epoch;
+  const visible = state.client === client && state.workspaceId === workspaceId && state.epoch === epoch ? state : emptyCatalogState(client, workspaceId, epoch, readAccess);
+  const update = (change) => setState((current) => {
+    if (!isCurrentScope()) return current;
+    const scoped = current.client === client && current.workspaceId === workspaceId && current.epoch === epoch ? current : emptyCatalogState(client, workspaceId, epoch, readAccess);
+    return change(scoped);
+  });
+  async function fetchConnections() {
+    if (readAccess !== true) return null;
+    const request = ++connectionRevision.current;
+    const live = () => isCurrentScope();
+    try {
+      const loaded = await client.listConnections(workspaceId);
+      if (live() && request > deniedConnectionRevision.current && request > successfulConnectionRevision.current) {
+        if (deniedConnectionRevision.current > successfulConnectionRevision.current) {
+          mutationAuthorityEpoch.current++;
+        }
+        successfulConnectionRevision.current = request;
+        update((current) => ({
+          ...current,
+          connections: loaded,
+          connectionsLoadFailed: false,
+          connectionsAccessDenied: false
+        }));
+      }
+      return live() && request > deniedConnectionRevision.current ? loaded : null;
+    } catch (error) {
+      const denied = isWorkspacePermissionDenied(error);
+      if (live() && denied && request > successfulConnectionRevision.current && request > deniedConnectionRevision.current) {
+        deniedConnectionRevision.current = request;
+        mutationAuthorityEpoch.current++;
+        update((current) => ({
+          ...current,
+          connections: null,
+          connectionsLoadFailed: true,
+          connectionsAccessDenied: true
+        }));
+      } else if (live() && !denied && request === connectionRevision.current && deniedConnectionRevision.current <= successfulConnectionRevision.current) {
+        update((current) => ({ ...current, connectionsLoadFailed: true }));
+      }
+      return null;
+    }
+  }
+  async function refresh() {
+    if (!workspaceId) return;
+    const request = ++refreshRevision.current;
+    const live = () => isCurrentScope() && refreshRevision.current === request;
+    update((current) => ({
+      ...current,
+      loading: true,
+      nativeConnectCatalog: { status: "loading", providers: [] }
+    }));
+    const nativeCatalog = (async () => {
+      if (context.accessContext === null) return;
+      try {
+        const providers = await client.connectTransport().catalog(workspaceId);
+        if (!Array.isArray(providers)) throw new Error("Invalid connect catalog");
+        if (live())
+          update((current) => ({
+            ...current,
+            nativeConnectCatalog: { status: "ready", providers }
+          }));
+      } catch {
+        if (live())
+          update((current) => ({
+            ...current,
+            nativeConnectCatalog: { status: "error", providers: [] }
+          }));
+      }
+    })();
+    try {
+      const [catalog, , socials, slackBindings, apiDefinitions, apiInstances] = await Promise.all([
+        // A deploy or failover answers briefly with 502/503: retry quietly.
+        retryTransient(() => client.listCapabilities(workspaceId), { shouldContinue: live }),
+        // Settles access independently even when the catalog request rejects.
+        fetchConnections(),
+        client.listSocialConnections(workspaceId).catch(() => null),
+        client.listSlackInstallationBindings(workspaceId).catch(() => null),
+        client.listIntegrationDefinitions(workspaceId).catch(() => null),
+        client.listApiIntegrations(workspaceId).catch(() => null),
+        nativeCatalog
+      ]);
+      if (!live()) return;
+      update((current) => ({
+        ...current,
+        items: catalog.items,
+        memberIntegrationSetup: catalog.memberIntegrationSetup,
+        socialConnections: socials ?? current.socialConnections,
+        slackInstallationBindings: slackBindings ?? current.slackInstallationBindings,
+        apiIntegrationDefinitions: apiDefinitions?.definitions ?? current.apiIntegrationDefinitions,
+        apiIntegrationInstances: apiInstances?.integrations ?? current.apiIntegrationInstances,
+        loadError: null,
+        revision: current.revision + 1
+      }));
+    } catch (error) {
+      if (!live()) return;
+      update((current) => ({
+        ...current,
+        loadError: error instanceof Error ? error : new Error(String(error))
+      }));
+      if (!isTransientServiceFailure(error)) {
+        toast.error("Couldn't load plugins", {
+          description: userErrorText(error)
+        });
+      }
+    } finally {
+      if (live()) update((current) => ({ ...current, loading: false }));
+    }
+  }
+  return {
+    authorityKey,
+    nativeConnectCatalog: visible.nativeConnectCatalog,
+    items: visible.items,
+    setItems: (items) => update((current) => ({ ...current, items })),
+    connections: visible.connections,
+    connectionsLoadFailed: visible.connectionsLoadFailed,
+    connectionsAccessDenied: visible.connectionsAccessDenied,
+    replaceConnection: (updated) => update(
+      (current) => callbackAuthorityEpoch !== mutationAuthorityEpoch.current || current.connectionsAccessDenied ? current : {
+        ...current,
+        connections: current.connections ? current.connections.some((entry) => entry.id === updated.id) ? current.connections.map((entry) => entry.id === updated.id ? updated : entry) : [...current.connections, updated] : [updated]
+      }
+    ),
+    fetchConnections,
+    apiIntegrationDefinitions: visible.apiIntegrationDefinitions,
+    apiIntegrationInstances: visible.apiIntegrationInstances,
+    socialConnections: visible.socialConnections,
+    slackInstallationBindings: visible.slackInstallationBindings,
+    memberIntegrationSetup: visible.memberIntegrationSetup,
+    loading: visible.loading,
+    loadError: visible.loadError,
+    revision: visible.revision,
+    refresh
+  };
+}
+
+export {
+  useCapabilitiesCatalog
+};
+//# sourceMappingURL=chunk-NDQJZ7HF.js.map

package/dist/chunk-NGJJJPZZ.js

@@ -0,0 +1,162 @@
+"use client";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+import {
+  PluginDetails
+} from "./chunk-KCBMFSMS.js";
+import {
+  SessionCapabilityFrame
+} from "./chunk-FO4LYKJL.js";
+import {
+  continueAfterCapabilitySetup
+} from "./chunk-52Y2X66Q.js";
+
+// src/app/components/capabilities/session-plugin-card.tsx
+import { useEffect, useRef, useState } from "react";
+import { pluginMcpUnavailableReason } from "@opengeni/contracts/plugin-discovery";
+import { jsx } from "react/jsx-runtime";
+var PREFIX = "plugin:marketplace/";
+function pluginDiscoveryId(capabilityId) {
+  if (!capabilityId.startsWith(PREFIX)) return null;
+  const [provider, name, ...rest] = capabilityId.slice(PREFIX.length).split("/");
+  return provider && name && rest.length === 0 ? `${provider}:${name}` : null;
+}
+function count(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function pluginSubtitle(item) {
+  const skills = item.skills?.length ?? 0;
+  const servers = (item.mcpServers ?? []).filter(
+    (server) => pluginMcpUnavailableReason(server) === null
+  ).length;
+  return [
+    item.author?.name ? `By ${item.author.name}` : "",
+    skills ? count(skills, "Skill", "Skills") : "",
+    servers ? count(servers, "MCP server", "MCP servers") : ""
+  ].filter(Boolean).join(" \xB7 ");
+}
+function SessionPluginCapabilityCard({
+  item,
+  workspaceId,
+  sessionId,
+  onConfigured
+}) {
+  const { client } = useAppContext();
+  const capability = item.capability;
+  const discoveryId = pluginDiscoveryId(capability.id);
+  const pluginKey = capability.id.slice("plugin:".length);
+  const [loaded, setLoaded] = useState({ state: "loading" });
+  const [expanded, setExpanded] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const [complete, setComplete] = useState(false);
+  const opener = useRef(null);
+  useEffect(() => {
+    if (!discoveryId) {
+      setLoaded({ state: "missing" });
+      return;
+    }
+    let live = true;
+    Promise.all([
+      client.discoverPlugins(workspaceId, { id: discoveryId }),
+      client.listInstalledPlugins(workspaceId).catch(() => ({ plugins: [] }))
+    ]).then(
+      ([page, installed]) => {
+        if (!live) return;
+        const plugin2 = page.items.find((entry) => entry.id === discoveryId);
+        if (!plugin2) {
+          setLoaded({ state: "missing" });
+          return;
+        }
+        const already = installed.plugins.some((entry) => entry.pluginKey === pluginKey);
+        setLoaded({ state: "ready", item: plugin2, installed: already });
+        if (already) setComplete(true);
+      },
+      () => {
+        if (live) setLoaded({ state: "missing" });
+      }
+    );
+    return () => {
+      live = false;
+    };
+  }, [client, discoveryId, pluginKey, workspaceId]);
+  const plugin = loaded.state === "ready" ? loaded.item : null;
+  const name = (plugin?.displayName ?? capability.name).replace(/-/g, " ");
+  const install = async () => {
+    if (!plugin?.sourceUrl || busy) return;
+    setBusy(true);
+    setError(null);
+    try {
+      const preview = await client.previewPlugin(workspaceId, {
+        url: plugin.sourceUrl,
+        bindings: {}
+      });
+      await client.installPlugin(workspaceId, {
+        url: plugin.sourceUrl,
+        bindings: {},
+        expectedManifestDigest: preview.manifestDigest,
+        expectedComponents: preview.components.map((component) => ({
+          key: component.key,
+          digest: component.digest
+        })),
+        idempotencyKey: crypto.randomUUID(),
+        ...preview.installationVersion !== null ? { expectedInstallationVersion: preview.installationVersion } : {}
+      });
+      setComplete(true);
+      setExpanded(false);
+      await onConfigured?.();
+      continueAfterCapabilitySetup(client, workspaceId, sessionId, capability.id);
+    } catch (cause) {
+      setError(userErrorText(cause, "Couldn't install the plugin."));
+    } finally {
+      setBusy(false);
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    SessionCapabilityFrame,
+    {
+      name,
+      subtitle: plugin && pluginSubtitle(plugin) || item.providerDomain,
+      logo: plugin?.logoUrl ?? null,
+      typeLabel: "Plugin",
+      description: capability.rationale || plugin?.description || "",
+      clampDescription: Boolean(capability.rationale),
+      skill: false,
+      expanded,
+      complete,
+      completeLabel: "Installed in this workspace.",
+      actionLabel: "Review plugin",
+      note: "Installing adds its Skills and MCP servers to this workspace for everyone. You can remove it in Capabilities.",
+      actionUnavailable: loaded.state === "missing" ? "This plugin isn't available here anymore. Ask the agent to search again." : void 0,
+      busy: busy || loaded.state === "loading",
+      opener,
+      onOpen: () => {
+        setError(null);
+        setExpanded(true);
+      },
+      onClose: () => setExpanded(false),
+      children: plugin ? /* @__PURE__ */ jsx(
+        PluginDetails,
+        {
+          item: plugin,
+          showIdentity: false,
+          busy,
+          installed: complete,
+          error,
+          onInstall: () => void install()
+        }
+      ) : null
+    }
+  );
+}
+
+export {
+  pluginDiscoveryId,
+  pluginSubtitle,
+  SessionPluginCapabilityCard
+};
+//# sourceMappingURL=chunk-NGJJJPZZ.js.map

package/dist/chunk-NJTSNNE7.js

@@ -0,0 +1,251 @@
+"use client";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  Input
+} from "./chunk-VPM3TXFC.js";
+import {
+  Button
+} from "./chunk-7QQN3KNP.js";
+
+// src/app/components/session/context-text-reader.tsx
+import { useVirtualizer } from "@tanstack/react-virtual";
+import { ArrowDownIcon, ArrowUpIcon, CopyIcon, SearchIcon, XIcon } from "lucide-react";
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function textBlocks(text) {
+  const blocks = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + 2e3, text.length);
+    if (end < text.length) {
+      const newline = text.lastIndexOf("\n", end);
+      if (newline > start + 1e3) end = newline + 1;
+      else {
+        const space = text.lastIndexOf(" ", end);
+        if (space > start + 1e3) end = space + 1;
+        else if (/[\uD800-\uDBFF]/.test(text[end - 1])) end--;
+      }
+    }
+    blocks.push({ start, text: text.slice(start, end) });
+    start = end;
+  }
+  return blocks;
+}
+function ContextTextReader({
+  text,
+  initialQuery = "",
+  code = false
+}) {
+  const root = useRef(null);
+  const body = useRef(null);
+  const search = useRef(null);
+  const [scrollElement, setScrollElement] = useState(null);
+  const [margin, setMargin] = useState(0);
+  const [finding, setFinding] = useState(Boolean(initialQuery));
+  const [query, setQuery] = useState(initialQuery);
+  const [occurrence, setOccurrence] = useState(0);
+  const [jumpRevision, setJumpRevision] = useState(0);
+  const pendingJump = useRef(true);
+  const blocks = useMemo(() => textBlocks(text), [text]);
+  const matches = useMemo(() => {
+    if (!query) return [];
+    const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const expression = new RegExp(escaped, "gi");
+    const result = [];
+    for (const match of text.matchAll(expression)) result.push(match.index);
+    return result;
+  }, [text, query]);
+  const active = matches[Math.min(occurrence, matches.length - 1)] ?? -1;
+  const large = text.length > 5e4;
+  useLayoutEffect(() => {
+    const viewport = root.current?.closest('[data-slot="scroll-area-viewport"]') ?? null;
+    setScrollElement(viewport);
+    const update = () => {
+      if (viewport && body.current)
+        setMargin(
+          body.current.getBoundingClientRect().top - viewport.getBoundingClientRect().top + viewport.scrollTop
+        );
+    };
+    update();
+    const observer = new ResizeObserver(update);
+    if (root.current) observer.observe(root.current);
+    if (viewport) observer.observe(viewport);
+    return () => observer.disconnect();
+  }, [finding]);
+  const virtualizer = useVirtualizer({
+    count: blocks.length,
+    getScrollElement: () => scrollElement,
+    estimateSize: (index) => Math.max(24, Math.ceil((blocks[index]?.text.length ?? 0) / 65) * 24),
+    scrollMargin: margin,
+    overscan: 3,
+    enabled: large,
+    initialRect: { width: 500, height: 600 }
+  });
+  useEffect(() => {
+    if (!pendingJump.current || active < 0 || !large || !scrollElement) return;
+    const index = blocks.findIndex(
+      (block) => active >= block.start && active < block.start + block.text.length
+    );
+    if (index >= 0) virtualizer.scrollToIndex(index, { align: "center" });
+  }, [active, blocks, large, scrollElement, virtualizer, jumpRevision]);
+  const virtualItems = virtualizer.getVirtualItems();
+  useLayoutEffect(() => {
+    if (!pendingJump.current || active < 0) return;
+    const mark = body.current?.querySelector("mark");
+    if (mark) {
+      mark.scrollIntoView?.({ block: "center" });
+      pendingJump.current = false;
+    }
+  });
+  const move = (delta) => {
+    pendingJump.current = true;
+    setJumpRevision((n) => n + 1);
+    setOccurrence((n) => (n + delta + matches.length) % Math.max(1, matches.length));
+  };
+  const renderText = (value, start) => {
+    const offset = Math.max(0, active - start);
+    const matchEnd = Math.min(value.length, active + query.length - start);
+    return finding && active >= 0 && matchEnd > 0 && active < start + value.length ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      value.slice(0, offset),
+      /* @__PURE__ */ jsx("mark", { className: "rounded-sm bg-amber-300/25 text-inherit", children: value.slice(offset, matchEnd) }),
+      value.slice(matchEnd)
+    ] }) : value;
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: root,
+      tabIndex: 0,
+      "aria-label": "Context text",
+      onPointerDown: (event) => {
+        if (!event.target.closest("button,input,a"))
+          root.current?.focus({ preventScroll: true });
+      },
+      className: "min-w-0",
+      onKeyDown: (event) => {
+        if ((event.metaKey || event.ctrlKey) && event.key === "f") {
+          event.preventDefault();
+          setFinding(true);
+          requestAnimationFrame(() => search.current?.focus());
+        }
+        if (event.key === "Escape") {
+          setFinding(false);
+          setQuery("");
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "sticky top-0 z-10 mb-3 flex min-w-0 items-center justify-between gap-2 border-b border-border bg-bg py-2", children: [
+          finding ? /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-1", children: [
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                ref: search,
+                autoFocus: true,
+                "aria-label": "Find in content",
+                placeholder: "Find in text\u2026",
+                className: "h-7 min-w-0 flex-1",
+                value: query,
+                onChange: (event) => {
+                  pendingJump.current = true;
+                  setQuery(event.target.value);
+                  setOccurrence(0);
+                },
+                onKeyDown: (event) => {
+                  if (event.key === "Enter") {
+                    event.preventDefault();
+                    move(event.shiftKey ? -1 : 1);
+                  }
+                }
+              }
+            ),
+            /* @__PURE__ */ jsx("span", { className: "shrink-0 text-2xs text-fg-subtle", "aria-live": "polite", children: query ? matches.length ? `${occurrence + 1}/${matches.length}` : "No results" : "" }),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "icon-xs",
+                "aria-label": "Previous match",
+                disabled: !matches.length,
+                onClick: () => move(-1),
+                children: /* @__PURE__ */ jsx(ArrowUpIcon, { className: "size-3" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "icon-xs",
+                "aria-label": "Next match",
+                disabled: !matches.length,
+                onClick: () => move(1),
+                children: /* @__PURE__ */ jsx(ArrowDownIcon, { className: "size-3" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "ghost",
+                size: "icon-xs",
+                "aria-label": "Close find",
+                onClick: () => {
+                  setFinding(false);
+                  setQuery("");
+                },
+                children: /* @__PURE__ */ jsx(XIcon, { className: "size-3" })
+              }
+            )
+          ] }) : /* @__PURE__ */ jsxs(Button, { size: "xs", variant: "ghost", onClick: () => setFinding(true), children: [
+            /* @__PURE__ */ jsx(SearchIcon, { className: "size-3" }),
+            "Find"
+          ] }),
+          !finding ? /* @__PURE__ */ jsxs(
+            Button,
+            {
+              size: "xs",
+              variant: "ghost",
+              onClick: async () => {
+                try {
+                  await navigator.clipboard.writeText(text);
+                  toast.success("Copied");
+                } catch {
+                  toast.error("Could not copy");
+                }
+              },
+              children: [
+                /* @__PURE__ */ jsx(CopyIcon, { className: "size-3" }),
+                "Copy"
+              ]
+            }
+          ) : null
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: body,
+            className: code ? "font-mono text-xs leading-6 text-fg-muted" : "mx-auto max-w-[72ch] font-sans text-[13px] leading-[21px] text-fg",
+            style: large ? { height: virtualizer.getTotalSize(), position: "relative" } : void 0,
+            children: large ? virtualItems.map((item) => /* @__PURE__ */ jsx(
+              "div",
+              {
+                "data-index": item.index,
+                ref: virtualizer.measureElement,
+                className: "absolute left-0 top-0 w-full whitespace-pre-wrap [overflow-wrap:anywhere]",
+                style: { transform: `translateY(${item.start - margin}px)` },
+                children: renderText(blocks[item.index].text, blocks[item.index].start)
+              },
+              item.key
+            )) : /* @__PURE__ */ jsx("div", { className: "whitespace-pre-wrap [overflow-wrap:anywhere]", children: renderText(text, 0) })
+          }
+        )
+      ]
+    }
+  );
+}
+
+export {
+  textBlocks,
+  ContextTextReader
+};
+//# sourceMappingURL=chunk-NJTSNNE7.js.map