@burdenoff/fluidgrids-fe-sdk 2026.1028.5 → 2026.1028.7

package/dist/{chunk-QGXA2USP.js → chunk-MKKBEVXO.js}

@@ -1,4 +1,4 @@
-import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-JBLYBD2B.js';
+import { FluidgridsEntityTagsDocument, AvailableFluidgridsTagsDocument, SearchFluidgridsTagsDocument, TagFluidgridsEntityDocument, UntagFluidgridsEntityDocument, ReplaceFluidgridsEntityTagsDocument, CreateFluidgridsTagDocument, DataTablesTagsDocument } from './chunk-6J4RR46J.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useCallback, useEffect } from 'react';
 

package/dist/chunk-MUOJVRW7.js

@@ -0,0 +1,328 @@
+import { throwIfResultError } from './chunk-6NUHJPGJ.js';
+import { RunFailureClustersDocument, DismissRunFailureClusterDocument, RunFailureTriageSettingsDocument, SetRunFailureTriageEnabledDocument, FgTriageFailedRunsDocument } from './chunk-6J4RR46J.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useCallback, useEffect } from 'react';
+import { Icon } from '@iconify/react';
+import { Button } from '@burdenoff/fe-libs/ui';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var OPEN_STATUSES = [
+  "OPEN" /* Open */,
+  "PROPOSED" /* Proposed */
+];
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function fetchRunFailureClusters(variables) {
+  const result = throwIfResultError(
+    await getFluidGridsClient().query({
+      query: RunFailureClustersDocument,
+      variables,
+      fetchPolicy: "network-only"
+    })
+  );
+  return result.data?.runFailureClusters.items ?? [];
+}
+async function dismissRunFailureCluster(id) {
+  throwIfResultError(
+    await getFluidGridsClient().mutate({ mutation: DismissRunFailureClusterDocument, variables: { id } })
+  );
+}
+function useFailureTriage() {
+  const [settings, setSettings] = useState(
+    null
+  );
+  const [clusters, setClusters] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const [lastRun, setLastRun] = useState(null);
+  const refetch = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const [settingsResult, items] = await Promise.all([
+        getFluidGridsClient().query({
+          query: RunFailureTriageSettingsDocument,
+          fetchPolicy: "network-only"
+        }),
+        fetchRunFailureClusters({
+          filter: { status: OPEN_STATUSES },
+          limit: 20
+        })
+      ]);
+      setSettings(
+        throwIfResultError(settingsResult).data?.runFailureTriageSettings ?? null
+      );
+      setClusters(items);
+    } catch (loadError) {
+      setError(messageOf(loadError));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  const setEnabled = useCallback(async (enabled) => {
+    setBusy(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: SetRunFailureTriageEnabledDocument,
+          variables: { enabled }
+        })
+      );
+      setSettings(result.data?.setRunFailureTriageEnabled ?? null);
+    } catch (toggleError) {
+      setError(messageOf(toggleError));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const runNow = useCallback(async () => {
+    setBusy(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: FgTriageFailedRunsDocument, variables: {} })
+      );
+      setLastRun(result.data?.fgTriageFailedRuns ?? null);
+      setClusters(
+        await fetchRunFailureClusters({
+          filter: { status: OPEN_STATUSES },
+          limit: 20
+        })
+      );
+    } catch (runError) {
+      setError(messageOf(runError));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const dismiss = useCallback(async (id) => {
+    setError(null);
+    try {
+      await dismissRunFailureCluster(id);
+      setClusters((current) => current.filter((cluster) => cluster.id !== id));
+    } catch (dismissError) {
+      setError(messageOf(dismissError));
+    }
+  }, []);
+  return {
+    settings,
+    clusters,
+    loading,
+    busy,
+    error,
+    lastRun,
+    refetch,
+    setEnabled,
+    runNow,
+    dismiss
+  };
+}
+var BUCKET_LABELS = {
+  EXPIRED_CONNECTION: {
+    label: "Expired connection",
+    icon: "mdi:key-alert-outline"
+  },
+  CONNECTOR_CONTRACT_CHANGE: {
+    label: "Connector change",
+    icon: "mdi:swap-horizontal"
+  },
+  BAD_NODE_CONFIG: { label: "Node configuration", icon: "mdi:cog-outline" },
+  UPSTREAM_TRANSIENT: { label: "Transient", icon: "mdi:weather-cloudy-alert" },
+  UNKNOWN: { label: "Unclassified", icon: "mdi:help-circle-outline" }
+};
+function ClusterRow({
+  cluster,
+  canRetry,
+  onOpenRun,
+  onRetry,
+  onDismiss
+}) {
+  const tr = useTr();
+  const bucket = BUCKET_LABELS[String(cluster.bucket)] ?? {
+    label: String(cluster.bucket),
+    icon: "mdi:alert-outline"
+  };
+  return /* @__PURE__ */ jsx(
+    "li",
+    {
+      className: "rounded-lg border border-border-secondary bg-background-primary p-3",
+      "data-testid": "failure-cluster",
+      "data-bucket": String(cluster.bucket),
+      children: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between", children: [
+        /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2 text-sm", children: [
+            /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 rounded-full bg-background-secondary px-2 py-0.5 text-xs text-text-secondary", children: [
+              /* @__PURE__ */ jsx(Icon, { icon: bucket.icon, width: 14 }),
+              tr(
+                `fluidgrids.triage.bucket.${String(cluster.bucket)}`,
+                bucket.label
+              )
+            ] }),
+            /* @__PURE__ */ jsx("span", { className: "font-medium text-text-primary", children: cluster.workflowName || cluster.workflowKey }),
+            /* @__PURE__ */ jsx("span", { className: "text-text-secondary", children: tr("fluidgrids.triage.atNode", "at {{node}}", {
+              node: cluster.nodeId
+            }) })
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "mt-1 break-words text-sm text-text-secondary", children: cluster.signature }),
+          /* @__PURE__ */ jsxs("p", { className: "mt-1 text-xs text-text-secondary", children: [
+            tr(
+              "fluidgrids.triage.runCount",
+              "{{count}} failed run(s), last {{when}}",
+              {
+                count: cluster.runCount,
+                when: new Date(String(cluster.lastSeenAt)).toLocaleString()
+              }
+            ),
+            cluster.proposalId ? ` \xB7 ${tr("fluidgrids.triage.proposalReady", "Fix proposal ready to review")}` : ""
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-text-primary", children: cluster.advice })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => onOpenRun(cluster.lastRunId),
+              "data-testid": "failure-cluster-open",
+              children: cluster.proposalId ? tr("fluidgrids.triage.reviewFix", "Review fix") : tr("fluidgrids.triage.openRun", "Open run")
+            }
+          ),
+          canRetry && /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "outline",
+              onClick: () => onRetry([cluster.lastRunId]),
+              children: tr("fluidgrids.triage.retry", "Retry")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "sm",
+              variant: "ghost",
+              onClick: () => onDismiss(cluster.id),
+              "data-testid": "failure-cluster-dismiss",
+              children: tr("fluidgrids.triage.dismiss", "Dismiss")
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
+function FailureTriagePanel({
+  canManage,
+  canRetry,
+  onOpenRun,
+  onRetry
+}) {
+  const tr = useTr();
+  const triage = useFailureTriage();
+  const enabled = triage.settings?.enabled ?? false;
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: "mb-6 rounded-xl border border-border-secondary bg-background-secondary p-4",
+      "data-testid": "failure-triage-panel",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between", children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsxs("h2", { className: "flex items-center gap-2 text-base font-semibold text-text-primary", children: [
+              /* @__PURE__ */ jsx(Icon, { icon: "mdi:stethoscope", width: 18 }),
+              tr("fluidgrids.triage.title", "Failure triage")
+            ] }),
+            /* @__PURE__ */ jsx("p", { className: "mt-1 max-w-2xl text-sm text-text-secondary", children: tr(
+              "fluidgrids.triage.description",
+              "Every hour, groups failed production runs, leaves temporary failures to the retry and prepares a fix proposal for you to review. It never changes a workflow on its own."
+            ) }),
+            /* @__PURE__ */ jsxs(
+              "p",
+              {
+                className: "mt-1 text-xs text-text-secondary",
+                "data-testid": "failure-triage-status",
+                children: [
+                  enabled ? tr("fluidgrids.triage.on", "On") : tr("fluidgrids.triage.off", "Off"),
+                  triage.settings?.lastTickAt ? ` \xB7 ${tr("fluidgrids.triage.lastRun", "last run {{when}}", {
+                    when: new Date(
+                      String(triage.settings.lastTickAt)
+                    ).toLocaleString()
+                  })}` : "",
+                  triage.settings && !triage.settings.killSwitchOn ? ` \xB7 ${tr("fluidgrids.triage.paused", "paused for this workspace")}` : ""
+                ]
+              }
+            )
+          ] }),
+          canManage && /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-2", children: [
+            enabled && /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: "outline",
+                onClick: () => void triage.runNow(),
+                disabled: triage.busy,
+                "data-testid": "failure-triage-run-now",
+                children: tr("fluidgrids.triage.runNow", "Run now")
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                size: "sm",
+                variant: enabled ? "outline" : "default",
+                onClick: () => void triage.setEnabled(!enabled),
+                disabled: triage.busy || triage.loading,
+                "data-testid": "failure-triage-toggle",
+                children: enabled ? tr("fluidgrids.triage.turnOff", "Turn off") : tr("fluidgrids.triage.turnOn", "Turn on")
+              }
+            )
+          ] })
+        ] }),
+        triage.error && /* @__PURE__ */ jsx("p", { className: "mt-3 text-sm text-status-error-text", children: triage.error }),
+        triage.lastRun && !triage.lastRun.skipped && /* @__PURE__ */ jsx("p", { className: "mt-3 text-xs text-text-secondary", children: tr(
+          "fluidgrids.triage.lastRunSummary",
+          "Checked {{scanned}} failed run(s): {{created}} new cluster(s), {{suppressed}} left to the retry.",
+          {
+            scanned: triage.lastRun.scannedRuns,
+            created: triage.lastRun.newClusterCount,
+            suppressed: triage.lastRun.suppressedTransient
+          }
+        ) }),
+        triage.clusters.length > 0 ? /* @__PURE__ */ jsx("ul", { className: "mt-4 space-y-2", "data-testid": "failure-cluster-list", children: triage.clusters.map((cluster) => /* @__PURE__ */ jsx(
+          ClusterRow,
+          {
+            cluster,
+            canRetry,
+            onOpenRun,
+            onRetry,
+            onDismiss: (id) => void triage.dismiss(id)
+          },
+          cluster.id
+        )) }) : !triage.loading && /* @__PURE__ */ jsx(
+          "p",
+          {
+            className: "mt-4 text-sm text-text-secondary",
+            "data-testid": "failure-triage-empty",
+            children: enabled ? tr(
+              "fluidgrids.triage.empty",
+              "No repeated failures need attention."
+            ) : tr(
+              "fluidgrids.triage.emptyOff",
+              "Turn failure triage on to have repeated failures grouped and explained here."
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { BUCKET_LABELS, FailureTriagePanel, OPEN_STATUSES, dismissRunFailureCluster, fetchRunFailureClusters };

package/dist/{chunk-JAKWVVVQ.js → chunk-NW6H7EN3.js}

@@ -1,7 +1,7 @@
-import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-QGXA2USP.js';
-import { throwIfResultError } from './chunk-5LKZ4PNK.js';
+import { useEntityTags, useTagEntity, useUntagEntity } from './chunk-MKKBEVXO.js';
+import { throwIfResultError } from './chunk-6NUHJPGJ.js';
 import { getFluidGridsConfig } from './chunk-CY6KX4RG.js';
-import { WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument } from './chunk-JBLYBD2B.js';
+import { WorkflowProposalDocument, ProposeRunFixDocument, ProposeWorkflowChangeDocument, ApplyWorkflowProposalDocument, RejectWorkflowProposalDocument, CancelWorkflowProposalDocument } from './chunk-6J4RR46J.js';
 import { useTr } from './chunk-UULVIT25.js';
 import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
 import { useState, useRef, useEffect, useCallback } from 'react';
@@ -257,6 +257,17 @@ function useWorkflowProposal() {
     },
     [clearTimer, poll]
   );
+  const open = useCallback(
+    async (id) => {
+      const run = ++runRef.current;
+      clearTimer();
+      setError(null);
+      setTimedOut(false);
+      setIsWorking(true);
+      await poll(run, id, Date.now());
+    },
+    [clearTimer, poll]
+  );
   const decide = useCallback(
     async (action) => {
       const id = proposal?.id;
@@ -310,6 +321,7 @@ function useWorkflowProposal() {
     error,
     timedOut,
     start,
+    open,
     apply,
     reject,
     cancel,