@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-XDFP2LMW.js

@@ -0,0 +1,605 @@
+"use client";
+import {
+  apiErrorFacts,
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+
+// src/app/lib/capabilities.tsx
+import { errorMessage } from "@opengeni/contracts/values";
+function capabilityKindLabel(kind) {
+  switch (kind) {
+    case "mcp":
+      return "MCP server";
+    case "api":
+      return "API";
+    case "skill":
+      return "Skill";
+    case "plugin":
+      return "Plugin";
+    default:
+      return kind;
+  }
+}
+function capabilityItemKindLabel(item) {
+  return item.surfaceType === "provider_integration" ? "Integration" : capabilityKindLabel(item.kind);
+}
+function capabilitySourceLabel(source) {
+  switch (source) {
+    case "built_in":
+      return "Built in";
+    case "library":
+      return "Curated library";
+    case "configured":
+      return "Configured";
+    case "public_registry":
+    case "registry":
+      return "Public registry";
+    case "manual":
+      return "Added";
+    default:
+      return String(source).replaceAll("_", " ");
+  }
+}
+function curatedSkillProvenance(item) {
+  if (item.kind !== "skill" || item.source !== "library") {
+    return null;
+  }
+  const metadata = item.metadata;
+  return {
+    libraryId: stringValue(metadata.libraryId),
+    version: stringValue(metadata.version),
+    contentSha256: stringValue(metadata.contentSha256),
+    sourceCommit: stringValue(metadata.sourceCommit),
+    provenance: stringValue(metadata.provenance) ?? item.provenance,
+    sourceUrl: stringValue(metadata.sourceUrl),
+    license: stringValue(metadata.license),
+    documentationUrl: stringValue(metadata.documentationUrl),
+    artifactPath: stringValue(metadata.artifactPath),
+    status: item.enabled ? "enabled" : "not_enabled",
+    effectiveSelection: item.enabled ? item.enabledReason ?? "enabled" : "not selected"
+  };
+}
+function emptyCapabilityForm() {
+  return {
+    kind: "mcp",
+    name: "",
+    description: "",
+    category: "custom",
+    tags: "",
+    endpointUrl: "",
+    homepageUrl: "",
+    installUrl: "",
+    enableAfterAdd: true
+  };
+}
+function isConnectorCatalogItem(item) {
+  return item.kind === "mcp" || item.kind === "api";
+}
+function filterCapabilityCatalogItems(items, filter, query) {
+  const normalized = query.trim().toLowerCase();
+  return items.filter((item) => {
+    if (filter !== "all" && item.kind !== filter) {
+      return false;
+    }
+    if (!normalized) {
+      return true;
+    }
+    return [
+      item.name,
+      item.description,
+      item.kind,
+      item.source,
+      item.category,
+      item.endpointUrl,
+      item.homepageUrl,
+      item.installUrl,
+      ...item.tags,
+      // Curation flags are presentation facts, not search terms; typing
+      // "official" must not match every curated connector.
+      JSON.stringify(metadataForSearch(item.metadata))
+    ].filter(Boolean).join(" ").toLowerCase().includes(normalized);
+  });
+}
+function capabilityErrorToast(error, fallbackTitle) {
+  if (isMissingCredentialsError(error)) {
+    return {
+      title: "Credentials needed",
+      description: "This integration needs to be connected before it can be enabled."
+    };
+  }
+  const serverMessage = cleanApiErrorMessage(apiErrorFacts(error).serverMessage ?? "");
+  const probe = /^MCP capability ".+" could not be enabled because (?:OpenGeni|Opengeni|the workspace) could not initialize (\S+?)\.?(?:\s|$)/u.exec(
+    serverMessage
+  );
+  if (probe) {
+    return {
+      title: "Connection failed",
+      description: `Opengeni couldn't connect to ${probe[1]}. Check the endpoint address, then try again.`
+    };
+  }
+  return { title: fallbackTitle, description: userErrorText(error) };
+}
+function isMissingCredentialsError(error) {
+  const message = errorMessage(error);
+  return /requires credentials/i.test(message) && /headers|credential|connection/i.test(message);
+}
+function cleanApiErrorMessage(message) {
+  return message.replace(/^API\s+\d+:\s*/i, "").trim();
+}
+function organizationConnectorTurnedOff(item) {
+  return item.kind === "mcp" && !item.enabled && item.lifecycle?.managedBy === "organization" && item.actions.includes("connect") && typeof item.metadata.organizationConnector === "object" && item.metadata.organizationConnector !== null;
+}
+function capabilityConnectPlan(item) {
+  if (item.surfaceType === "first_party_social" || item.surfaceType === "provider_integration" && item.metadata.providerAdapter === "social") {
+    const provider = stringValue(item.metadata.provider);
+    if (provider === "x" || provider === "reddit") {
+      return { mode: "social_oauth", provider };
+    }
+  }
+  if (item.surfaceType === "first_party_fiken") {
+    return { mode: "fiken_api_token" };
+  }
+  if (item.kind !== "mcp") {
+    return { mode: "dedicated" };
+  }
+  if (organizationConnectorTurnedOff(item)) {
+    return { mode: "enable" };
+  }
+  const providerDomain = item.providerDomain ?? domainFromUrl(item.mcpUrl ?? item.endpointUrl) ?? "";
+  if (item.authKind === "oauth2") {
+    return {
+      mode: "oauth",
+      providerDomain,
+      mcpUrl: item.mcpUrl ?? item.endpointUrl,
+      requestedScopes: stringArray(item.metadata.scopesHint)
+    };
+  }
+  const requiredHeaders = stringArray(item.metadata.requiredHeaders);
+  if (requiredHeaders.length > 0) {
+    return {
+      mode: "api_key",
+      providerDomain,
+      fields: requiredHeaders.map(headerField)
+    };
+  }
+  if (item.authKind === "api_key" || item.authModel === "credential_ref") {
+    return { mode: "api_key", providerDomain, fields: [GENERIC_API_KEY_FIELD] };
+  }
+  if (item.metadata.authDiscovery === "unknown" || item.metadata.authDiscovery === "checking" || (item.source === "public_registry" || item.source === "manual") && item.authKind == null && item.metadata.authDiscovery !== "none") {
+    return { mode: "setup_required" };
+  }
+  return { mode: "enable" };
+}
+var DEFAULT_CONNECTION_OWNERSHIP = "workspace";
+function capabilityQuickConnectPlan(item) {
+  const plan = capabilityConnectPlan(item);
+  const ownership = defaultCapabilityConnectionOwnership(item);
+  if (plan.mode === "enable") return { mode: "enable" };
+  if (plan.mode === "oauth") {
+    return {
+      mode: "oauth",
+      ownership,
+      providerDomain: plan.providerDomain,
+      mcpUrl: plan.mcpUrl,
+      confirm: !capabilityCuration(item).official
+    };
+  }
+  if (plan.mode === "api_key") {
+    if (plan.fields.length > 1) return null;
+    return {
+      mode: "api_key",
+      ownership,
+      providerDomain: plan.providerDomain,
+      field: plan.fields[0] ?? GENERIC_API_KEY_FIELD
+    };
+  }
+  return null;
+}
+function apiKeyCredential(field, value) {
+  return { headers: { [field.name]: value } };
+}
+function defaultCapabilityConnectionOwnership(item) {
+  const preferred = item.metadata.defaultConnectionOwnership ?? recordValue(item.metadata.oauthProfile)?.defaultOwnership;
+  return preferred === "personal" ? "personal" : DEFAULT_CONNECTION_OWNERSHIP;
+}
+function capabilityCuration(item) {
+  const raw = item.metadata.curation;
+  const record = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+  return {
+    curated: record?.curated === true,
+    featured: record?.featured === true,
+    official: record?.official === true
+  };
+}
+function sortFeaturedFirst(items) {
+  const featured = [];
+  const rest = [];
+  for (const item of items) {
+    (capabilityCuration(item).featured ? featured : rest).push(item);
+  }
+  return [...featured, ...rest];
+}
+function metadataForSearch(metadata) {
+  if (!("curation" in metadata)) return metadata;
+  const { curation: _curation, ...rest } = metadata;
+  return rest;
+}
+var CATEGORY_LABELS = {
+  analytics: "Analytics",
+  automation: "Automation",
+  communication: "Communication",
+  configured: "Configured",
+  data: "Data",
+  design: "Design",
+  "developer-tools": "Developer tools",
+  files: "Files",
+  finance: "Finance",
+  integrations: "Integrations",
+  marketing: "Marketing",
+  productivity: "Productivity",
+  "project-management": "Project management",
+  "public-mcp": "Public MCP",
+  sales: "Sales",
+  scheduling: "Scheduling",
+  "social-media": "Social media",
+  "source-control": "Source control",
+  web: "Web"
+};
+function capabilityCategoryLabel(category) {
+  if (!category || category === "custom") return null;
+  const known = CATEGORY_LABELS[category];
+  if (known) return known;
+  return category.split(/[-_\s]+/).filter(Boolean).map(
+    (word, index) => index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word.toLowerCase()
+  ).join(" ");
+}
+function capabilityAuthHint(item) {
+  const plan = capabilityConnectPlan(item);
+  if (plan.mode === "oauth" || plan.mode === "social_oauth") return "OAuth";
+  if (plan.mode === "api_key" || plan.mode === "fiken_api_token") return "API key";
+  return null;
+}
+function capabilityStateChip(item, health) {
+  if (!item.enabled) return { label: "Not connected", tone: "idle" };
+  if (health?.state === "unverified") return { label: "Loading", tone: "plain" };
+  if (health?.state === "attention") return { label: "Needs attention", tone: "warn" };
+  return { label: "Connected", tone: "ok" };
+}
+function preferredSocialConnection(connections, provider) {
+  return socialConnectionsForOwnership(
+    connections.filter((connection) => connection.provider === provider)
+  )[0] ?? null;
+}
+function socialConnectionsForOwnership(connections, ownership) {
+  const statusRank = (status) => status === "connected" ? 0 : status === "needs_reauth" ? 1 : 2;
+  return connections.filter((connection) => ownership === void 0 || connection.ownership === ownership).sort(
+    (left, right) => statusRank(left.status) - statusRank(right.status) || right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id)
+  );
+}
+function headerField(name) {
+  return { name, label: headerFieldLabel(name) };
+}
+var headerLabelAcronyms = /* @__PURE__ */ new Set(["API", "URL", "JWT", "SSO", "OTP", "PAT"]);
+function headerFieldLabel(name) {
+  if (/api[\s_-]?key/i.test(name) || /^authorization$/i.test(name)) {
+    return "API key";
+  }
+  const cleaned = name.replace(/^x-/i, "").replaceAll(/[-_]+/g, " ").trim();
+  const titled = cleaned.split(/\s+/).map(
+    (word) => word === word.toUpperCase() && word.length > 2 && !headerLabelAcronyms.has(word) ? word[0] + word.slice(1).toLowerCase() : word.replace(/^\w/, (character) => character.toUpperCase())
+  ).join(" ");
+  return titled || "Credential";
+}
+function domainFromUrl(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).hostname || null;
+  } catch {
+    return null;
+  }
+}
+function installedConnectionRef(item) {
+  return item.connectionRef ?? null;
+}
+function resolveSheetItem(selected, items) {
+  if (!selected) return null;
+  return items.find((entry) => entry.id === selected.id) ?? (selected.snapshotFallback ? selected.snapshot : null);
+}
+function fikenWorkspaceConnection(connections) {
+  const statusRank = (status) => status === "active" ? 0 : status === "needs_reauth" ? 1 : 2;
+  return connections.filter(
+    (connection) => connection.subjectId === null && // Both verified lanes: pasted personal API token and registered-app
+    // OAuth. Must stay in sync with `isFikenConnection` in @opengeni/core.
+    (connection.kind === "api_key" || connection.kind === "oauth2") && normalizeProviderDomain(connection.providerDomain) === "fiken.no" && connection.metadata.credentialRole === "fiken_api_token"
+  ).sort(
+    (left, right) => statusRank(left.status) - statusRank(right.status) || right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id)
+  )[0] ?? null;
+}
+function connectionHealth(item, connections, loaded) {
+  if (item.surfaceType === "first_party_fiken") {
+    if (!loaded) return { state: "unverified" };
+    const connection2 = fikenWorkspaceConnection(connections);
+    if (!connection2) return { state: "none" };
+    if (connection2.status !== "active") return { state: "attention", connection: connection2 };
+    return { state: "connected", connection: connection2 };
+  }
+  const ref = installedConnectionRef(item);
+  if (!ref) return { state: "none" };
+  if (ref.authoritySource === "host") return { state: "none" };
+  if (!loaded) return { state: "unverified" };
+  if (ref.accountSelection === "all_eligible" && !ref.connectionId) {
+    const matching = connections.filter(
+      (candidate) => candidate.kind === ref.kind && normalizeProviderDomain(candidate.providerDomain) === normalizeProviderDomain(ref.providerDomain)
+    );
+    const connection2 = matching.find((candidate) => candidate.status === "active") ?? matching[0] ?? null;
+    return connection2?.status === "active" ? { state: "connected", connection: connection2 } : { state: "attention", connection: connection2 };
+  }
+  const connection = ref.subjectScope === "subject" ? connections.find(
+    (candidate) => candidate.subjectId !== null && normalizeProviderDomain(candidate.providerDomain) === normalizeProviderDomain(ref.providerDomain) && candidate.kind === ref.kind
+  ) ?? null : connections.find((candidate) => candidate.id === ref.connectionId) ?? null;
+  if (!connection || connection.status !== "active") return { state: "attention", connection };
+  return { state: "connected", connection };
+}
+function capabilityReconnectPlan(item, health) {
+  if (!item.enabled || health.state !== "attention") return null;
+  const ref = item.connectionRef;
+  if (!ref) return null;
+  if (ref.authoritySource === "host") return null;
+  const connectionId = health.connection?.id ?? null;
+  return ref.kind === "oauth2" ? {
+    kind: "oauth",
+    connectionId,
+    ownership: ref.subjectScope === "subject" ? "personal" : "workspace"
+  } : {
+    kind: "api_key",
+    connectionId,
+    ownership: ref.subjectScope === "subject" ? "personal" : "workspace"
+  };
+}
+var GENERIC_API_KEY_FIELD = {
+  name: "Authorization",
+  label: "API key"
+};
+function workspaceConnectionForDomain(connections, providerDomain) {
+  const target = normalizeProviderDomain(providerDomain);
+  return connections.find(
+    (connection) => connection.subjectId === null && normalizeProviderDomain(connection.providerDomain) === target
+  ) ?? null;
+}
+function connectionToReuseForApiKey(item, connections, providerDomain, ownership = "workspace") {
+  const target = normalizeProviderDomain(providerDomain);
+  const matching = connections.find(
+    (connection) => (ownership === "personal" ? connection.subjectId !== null : connection.subjectId === null) && connection.kind === "api_key" && normalizeProviderDomain(connection.providerDomain) === target
+  );
+  return (ownership === "workspace" ? item.connectionRef?.connectionId : null) ?? matching?.id ?? null;
+}
+function registryResultsForQuery(query, searched, results) {
+  return searched !== null && searched === query.trim() ? results : [];
+}
+function normalizeProviderDomain(domain) {
+  return domain.trim().toLowerCase().replace(/^www\./, "");
+}
+function oauthResumeAction(item, connectionId) {
+  if (!item) return "missing";
+  if (!connectionId) return "no_connection";
+  if (item.enabled && item.connectionRef?.subjectScope === "subject") return "reconnect";
+  if (item.enabled && item.connectionRef?.connectionId === connectionId) return "reconnect";
+  return "enable";
+}
+function subjectOAuthConnectionRef(providerDomain) {
+  return { providerDomain, kind: "oauth2", subjectScope: "subject" };
+}
+function catalogConnectionAccountSelection(item) {
+  if (item.connectionRef?.connectionId) return void 0;
+  return !item.enabled || item.connectionRef?.accountSelection === "all_eligible" ? "all_eligible" : void 0;
+}
+function oauthConnectionRef(ownership, connectionId, providerDomain, accountSelection) {
+  if (accountSelection)
+    return {
+      providerDomain,
+      kind: "oauth2",
+      subjectScope: ownership === "personal" ? "subject" : "workspace",
+      accountSelection
+    };
+  return ownership === "personal" ? subjectOAuthConnectionRef(providerDomain) : {
+    connectionId,
+    providerDomain,
+    kind: "oauth2",
+    subjectScope: "workspace"
+  };
+}
+function apiKeyConnectionRef(ownership, connectionId, providerDomain, accountSelection) {
+  if (accountSelection)
+    return {
+      providerDomain,
+      kind: "api_key",
+      subjectScope: ownership === "personal" ? "subject" : "workspace",
+      accountSelection
+    };
+  return ownership === "personal" ? { providerDomain, kind: "api_key", subjectScope: "subject" } : {
+    connectionId,
+    providerDomain,
+    kind: "api_key",
+    subjectScope: "workspace"
+  };
+}
+function oauthConnectionOwnership(value) {
+  return value === "workspace" || value === "personal" ? value : null;
+}
+function capabilityMonogram(name) {
+  const words = name.trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return "?";
+  if (words.length === 1) return words[0].slice(0, 2).toUpperCase();
+  return (words[0][0] + words[1][0]).toUpperCase();
+}
+function scheduleSummaryForMetadata(value) {
+  const schedule = recordValue(value);
+  if (!schedule) {
+    return "Custom schedule";
+  }
+  const type = stringValue(schedule.type);
+  if (type === "calendar") {
+    const hour = numberValue(schedule.hour);
+    const minute = numberValue(schedule.minute);
+    const timeZone = stringValue(schedule.timeZone) ?? "UTC";
+    if (hour !== null && minute !== null) {
+      return `Calendar at ${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")} ${timeZone}`;
+    }
+    return `Calendar schedule in ${timeZone}`;
+  }
+  if (type === "interval") {
+    const everySeconds = numberValue(schedule.everySeconds);
+    return everySeconds ? `Every ${everySeconds} seconds` : "Interval schedule";
+  }
+  if (type === "once") {
+    return stringValue(schedule.runAt) ? `Once at ${stringValue(schedule.runAt)}` : "One-time schedule";
+  }
+  return type ? `${type} schedule` : "Custom schedule";
+}
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map(stringValue).filter((entry) => Boolean(entry)) : [];
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function capabilityCounts(items) {
+  return {
+    all: items.length,
+    mcp: items.filter((item) => item.kind === "mcp").length,
+    api: items.filter((item) => item.kind === "api").length,
+    skill: items.filter((item) => item.kind === "skill").length,
+    plugin: items.filter((item) => item.kind === "plugin").length
+  };
+}
+function capabilityFilterLabel(kind) {
+  switch (kind) {
+    case "all":
+      return "All";
+    case "mcp":
+      return "MCP servers";
+    case "api":
+      return "APIs";
+    case "skill":
+      return "Skills";
+    case "plugin":
+      return "Plugins";
+    default:
+      return kind;
+  }
+}
+function createInputFromCatalogItem(item) {
+  if (item.kind !== "mcp") {
+    throw new Error(
+      `${capabilityKindLabel(item.kind)} catalog items must use their dedicated install flow`
+    );
+  }
+  return {
+    id: item.id,
+    kind: item.kind,
+    source: item.source,
+    name: item.name,
+    ...item.description ? { description: item.description } : {},
+    category: item.category,
+    tags: item.tags,
+    ...item.homepageUrl ? { homepageUrl: item.homepageUrl } : {},
+    ...item.endpointUrl ? { endpointUrl: item.endpointUrl } : {},
+    ...item.installUrl ? { installUrl: item.installUrl } : {},
+    ...item.authModel ? { authModel: item.authModel } : {},
+    metadata: item.metadata
+  };
+}
+function capabilityFormError(form) {
+  if (!form.name.trim()) {
+    return "Give it a name.";
+  }
+  const url = form.endpointUrl.trim();
+  if (!url) {
+    return "Enter the MCP server URL.";
+  }
+  if (!isLikelyUrl(url)) {
+    return "Enter a valid URL, including https://.";
+  }
+  return null;
+}
+function isLikelyUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function capabilityInputFromForm(form) {
+  const name = form.name.trim();
+  if (!name) {
+    return null;
+  }
+  return {
+    kind: form.kind,
+    source: "manual",
+    name,
+    ...form.description.trim() ? { description: form.description.trim() } : {},
+    category: form.category.trim() || "custom",
+    tags: form.tags.split(",").map((tag) => tag.trim()).filter(Boolean),
+    ...form.endpointUrl.trim() ? { endpointUrl: form.endpointUrl.trim() } : {},
+    ...form.homepageUrl.trim() ? { homepageUrl: form.homepageUrl.trim() } : {},
+    ...form.installUrl.trim() ? { installUrl: form.installUrl.trim() } : {}
+  };
+}
+
+export {
+  capabilityKindLabel,
+  capabilityItemKindLabel,
+  capabilitySourceLabel,
+  curatedSkillProvenance,
+  emptyCapabilityForm,
+  isConnectorCatalogItem,
+  filterCapabilityCatalogItems,
+  capabilityErrorToast,
+  isMissingCredentialsError,
+  cleanApiErrorMessage,
+  organizationConnectorTurnedOff,
+  capabilityConnectPlan,
+  DEFAULT_CONNECTION_OWNERSHIP,
+  capabilityQuickConnectPlan,
+  apiKeyCredential,
+  defaultCapabilityConnectionOwnership,
+  capabilityCuration,
+  sortFeaturedFirst,
+  capabilityCategoryLabel,
+  capabilityAuthHint,
+  capabilityStateChip,
+  preferredSocialConnection,
+  socialConnectionsForOwnership,
+  domainFromUrl,
+  installedConnectionRef,
+  resolveSheetItem,
+  fikenWorkspaceConnection,
+  connectionHealth,
+  capabilityReconnectPlan,
+  GENERIC_API_KEY_FIELD,
+  workspaceConnectionForDomain,
+  connectionToReuseForApiKey,
+  registryResultsForQuery,
+  normalizeProviderDomain,
+  oauthResumeAction,
+  subjectOAuthConnectionRef,
+  catalogConnectionAccountSelection,
+  oauthConnectionRef,
+  apiKeyConnectionRef,
+  oauthConnectionOwnership,
+  capabilityMonogram,
+  scheduleSummaryForMetadata,
+  capabilityCounts,
+  capabilityFilterLabel,
+  createInputFromCatalogItem,
+  capabilityFormError,
+  capabilityInputFromForm
+};
+//# sourceMappingURL=chunk-XDFP2LMW.js.map