@burdenoff/fluidgrids-fe-sdk 2026.922.13 → 2026.923.2

package/dist/chunk-5A7GP6O7.js

@@ -0,0 +1,729 @@
+import { LOG_STREAM_DESTINATIONS, CREATE_LOG_STREAM_DESTINATION, UPDATE_LOG_STREAM_DESTINATION, DELETE_LOG_STREAM_DESTINATION, TEST_LOG_STREAM_DESTINATION, REPLAY_WORKFLOW_RUN, RETRY_WORKFLOW_RUNS, OBSERVABILITY_DASHBOARD_SUMMARY, OBSERVABILITY_FAILED_RUNS, OBSERVABILITY_DATA_SINKS, OBSERVABILITY_DATA_SINK_DATA } from './chunk-NK32XOQN.js';
+import { throwIfResultError, describeOperationError } from './chunk-LMO5ASOE.js';
+import { useTr } from './chunk-7YWBH2A5.js';
+import { getFluidGridsClient } from './chunk-5BDQNSP3.js';
+import { useCallback, useState, useMemo, useEffect } from 'react';
+import { Icon } from '@iconify/react';
+import { toast } from 'sonner';
+import { Button } from '@burdenoff/fe-libs/button';
+import { Card, CardHeader, CardContent, Label, Input } from '@burdenoff/fe-libs/ui';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function useAsyncRefresh(fetcher, initial) {
+  const [data, setData] = useState(initial);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refetch = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const next = await fetcher();
+      setData(next);
+      return next;
+    } catch (cause) {
+      const nextError = new Error(describeOperationError(cause));
+      setError(nextError);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetcher]);
+  useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { data, loading, error, refetch };
+}
+function useLogStreamDestinations() {
+  const fetchDestinations = useCallback(async () => {
+    const result = throwIfResultError(
+      await getFluidGridsClient().query({
+        query: LOG_STREAM_DESTINATIONS,
+        fetchPolicy: "network-only"
+      })
+    );
+    return result.data?.logStreamDestinations ?? [];
+  }, []);
+  const state = useAsyncRefresh(fetchDestinations, []);
+  return { destinations: state.data ?? [], ...state, refetch: state.refetch };
+}
+function useLogStreamDestinationActions() {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const run = useCallback(
+    async (operation) => {
+      setLoading(true);
+      setError(null);
+      try {
+        return await operation();
+      } catch (cause) {
+        const nextError = new Error(describeOperationError(cause));
+        setError(nextError);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    []
+  );
+  const create = useCallback(
+    (input) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: CREATE_LOG_STREAM_DESTINATION,
+          variables: { input }
+        })
+      );
+      return result.data?.createLogStreamDestination ?? null;
+    }),
+    [run]
+  );
+  const update = useCallback(
+    (id, input) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: UPDATE_LOG_STREAM_DESTINATION,
+          variables: { id, input }
+        })
+      );
+      return result.data?.updateLogStreamDestination ?? null;
+    }),
+    [run]
+  );
+  const remove = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: DELETE_LOG_STREAM_DESTINATION,
+          variables: { id }
+        })
+      );
+      return result.data?.deleteLogStreamDestination ?? null;
+    }),
+    [run]
+  );
+  const test = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: TEST_LOG_STREAM_DESTINATION,
+          variables: { id }
+        })
+      );
+      return result.data?.testLogStreamDestination ?? null;
+    }),
+    [run]
+  );
+  return { create, update, remove, test, loading, error };
+}
+function useRunReplayActions() {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const replay = useCallback(async (runId) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: REPLAY_WORKFLOW_RUN,
+          variables: { runId }
+        })
+      );
+      return result.data?.replayWorkflowRun ?? null;
+    } catch (cause) {
+      const nextError = new Error(describeOperationError(cause));
+      setError(nextError);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const retryMany = useCallback(async (runIds) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: RETRY_WORKFLOW_RUNS,
+          variables: { runIds }
+        })
+      );
+      return result.data?.retryWorkflowRuns ?? [];
+    } catch (cause) {
+      const nextError = new Error(describeOperationError(cause));
+      setError(nextError);
+      return [];
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  return { replay, retryMany, loading, error };
+}
+function useInsightsData() {
+  const fetchInsights = useCallback(async () => {
+    const client = getFluidGridsClient();
+    const [summaryResult, failedResult] = await Promise.all([
+      client.query({
+        query: OBSERVABILITY_DASHBOARD_SUMMARY,
+        fetchPolicy: "network-only"
+      }),
+      client.query({
+        query: OBSERVABILITY_FAILED_RUNS,
+        variables: {
+          input: {
+            status: "FAILED",
+            limit: 100,
+            offset: 0
+          }
+        },
+        fetchPolicy: "network-only"
+      })
+    ]);
+    throwIfResultError(summaryResult);
+    throwIfResultError(failedResult);
+    return {
+      summary: summaryResult.data?.dashboardSummary ?? null,
+      failedRuns: failedResult.data?.workflowRuns.items ?? []
+    };
+  }, []);
+  const state = useAsyncRefresh(fetchInsights, null);
+  return {
+    summary: state.data?.summary ?? null,
+    failedRuns: state.data?.failedRuns ?? [],
+    loading: state.loading,
+    error: state.error,
+    refetch: state.refetch
+  };
+}
+function useDataSinks(search) {
+  const fetchSinks = useCallback(async () => {
+    const result = throwIfResultError(
+      await getFluidGridsClient().query({
+        query: OBSERVABILITY_DATA_SINKS,
+        variables: { first: 50, isActive: true, search: search || void 0 },
+        fetchPolicy: "network-only"
+      })
+    );
+    return result.data?.listDataSinks ?? null;
+  }, [search]);
+  const state = useAsyncRefresh(fetchSinks, null);
+  return {
+    sinks: state.data?.edges.map((edge) => edge.node) ?? [],
+    totalCount: state.data?.totalCount ?? 0,
+    hasNextPage: state.data?.pageInfo.hasNextPage ?? false,
+    ...state
+  };
+}
+function useDataSinkData(sink) {
+  const fetchData = useCallback(async () => {
+    if (!sink) return null;
+    const result = throwIfResultError(
+      await getFluidGridsClient().query({
+        query: OBSERVABILITY_DATA_SINK_DATA,
+        variables: { id: sink.id, limit: 100, offset: 0 },
+        fetchPolicy: "network-only"
+      })
+    );
+    return result.data?.getDataSinkData ?? null;
+  }, [sink]);
+  const state = useAsyncRefresh(fetchData, null);
+  return { sinkData: state.data, ...state };
+}
+
+// src/modules/observability/types.ts
+var LOG_STREAM_EVENT_TYPES = [
+  "LOG_ERROR",
+  "LOG_WARN",
+  "NODE_FAILED",
+  "NODE_RETRIED",
+  "RUN_CANCELLED",
+  "RUN_COMPLETED",
+  "RUN_FAILED",
+  "RUN_STARTED"
+];
+var DEFAULT_EVENT_FILTERS = [
+  "RUN_FAILED",
+  "NODE_FAILED",
+  "LOG_ERROR"
+];
+var PROVIDERS = ["WEBHOOK", "SYSLOG", "SENTRY"];
+function emptyForm() {
+  return {
+    name: "",
+    provider: "WEBHOOK",
+    endpoint: "",
+    eventFilters: DEFAULT_EVENT_FILTERS,
+    isEnabled: true,
+    secret: "",
+    configText: "{}"
+  };
+}
+function formFromDestination(destination) {
+  return {
+    name: destination.name,
+    provider: destination.provider,
+    endpoint: destination.endpoint,
+    eventFilters: destination.eventFilters,
+    isEnabled: destination.isEnabled,
+    secret: "",
+    configText: JSON.stringify(destination.config ?? {}, null, 2)
+  };
+}
+function eventLabel(event) {
+  return event.toLowerCase().split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function endpointPlaceholder(provider) {
+  switch (provider) {
+    case "SYSLOG":
+      return "logs.example.com:514";
+    case "SENTRY":
+      return "https://public@sentry.example/1";
+    case "WEBHOOK":
+      return "https://hooks.example.com/workflows";
+  }
+}
+function parseConfig(configText) {
+  try {
+    const parsed = JSON.parse(configText || "{}");
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function formToInput(form) {
+  const config = parseConfig(form.configText);
+  if (!config || !form.name.trim() || !form.endpoint.trim()) return null;
+  return {
+    name: form.name.trim(),
+    provider: form.provider,
+    endpoint: form.endpoint.trim(),
+    eventFilters: form.eventFilters,
+    isEnabled: form.isEnabled,
+    config,
+    ...form.secret ? { secret: form.secret } : {}
+  };
+}
+function LogStreamingTab() {
+  const tr = useTr();
+  const { destinations, loading, error, refetch } = useLogStreamDestinations();
+  const actions = useLogStreamDestinationActions();
+  const [form, setForm] = useState(emptyForm);
+  const [editingId, setEditingId] = useState(null);
+  const [showForm, setShowForm] = useState(false);
+  const editingDestination = useMemo(
+    () => destinations.find((destination) => destination.id === editingId),
+    [destinations, editingId]
+  );
+  useEffect(() => {
+    if (editingDestination) setForm(formFromDestination(editingDestination));
+  }, [editingDestination]);
+  const resetForm = useCallback(() => {
+    setForm(emptyForm());
+    setEditingId(null);
+    setShowForm(false);
+  }, []);
+  const save = useCallback(async () => {
+    const input = formToInput(form);
+    if (!input) {
+      toast.error(
+        tr(
+          "fluidgrids.settings.logStreaming.invalidForm",
+          "Enter a name, endpoint, and valid JSON configuration."
+        )
+      );
+      return;
+    }
+    const result = editingId ? await actions.update(editingId, input) : await actions.create(input);
+    if (!result?.success) {
+      toast.error(
+        result?.message || tr(
+          "fluidgrids.settings.logStreaming.saveFailed",
+          "Could not save log streaming destination."
+        )
+      );
+      return;
+    }
+    toast.success(
+      tr(
+        "fluidgrids.settings.logStreaming.saved",
+        "Log streaming destination saved."
+      )
+    );
+    resetForm();
+    await refetch();
+  }, [actions, editingId, form, refetch, resetForm, tr]);
+  const remove = useCallback(
+    async (destination) => {
+      if (!window.confirm(`Delete \u201C${destination.name}\u201D?`)) return;
+      const result = await actions.remove(destination.id);
+      if (!result?.success) {
+        toast.error(
+          result?.message || tr(
+            "fluidgrids.settings.logStreaming.deleteFailed",
+            "Could not delete destination."
+          )
+        );
+        return;
+      }
+      toast.success(
+        tr(
+          "fluidgrids.settings.logStreaming.deleted",
+          "Log streaming destination deleted."
+        )
+      );
+      if (editingId === destination.id) resetForm();
+      await refetch();
+    },
+    [actions, editingId, refetch, resetForm, tr]
+  );
+  const sendTest = useCallback(
+    async (destination) => {
+      const result = await actions.test(destination.id);
+      if (!result) return;
+      if (result.success) {
+        toast.success(
+          tr(
+            "fluidgrids.settings.logStreaming.testSucceeded",
+            "Test event delivered."
+          )
+        );
+      } else {
+        toast.error(
+          result.message || tr(
+            "fluidgrids.settings.logStreaming.testFailed",
+            "Test event could not be delivered."
+          )
+        );
+      }
+      await refetch();
+    },
+    [actions, refetch, tr]
+  );
+  const toggleEvent = (event) => {
+    setForm((current) => ({
+      ...current,
+      eventFilters: current.eventFilters.includes(event) ? current.eventFilters.filter((item) => item !== event) : [...current.eventFilters, event]
+    }));
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-6", 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__ */ jsx("h2", { className: "text-lg font-semibold text-text-primary", children: tr("fluidgrids.settings.logStreaming.title", "Log streaming") }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 max-w-2xl text-sm text-text-secondary", children: tr(
+          "fluidgrids.settings.logStreaming.description",
+          "Send workflow run and node events to workspace-managed observability destinations. Secrets are write-only and never returned."
+        ) })
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          onClick: () => {
+            setForm(emptyForm());
+            setEditingId(null);
+            setShowForm(true);
+          },
+          disabled: actions.loading,
+          children: [
+            /* @__PURE__ */ jsx(Icon, { icon: "mdi:plus", className: "mr-1", width: 16 }),
+            tr("fluidgrids.settings.logStreaming.add", "Add destination")
+          ]
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "alert",
+        className: "rounded-lg border border-status-error-border bg-status-error-bg-subtle p-4 text-sm text-status-error-text",
+        children: [
+          error.message,
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "outline",
+              size: "sm",
+              className: "ml-3",
+              onClick: () => void refetch(),
+              children: tr("fluidgrids.settings.logStreaming.retry", "Retry")
+            }
+          )
+        ]
+      }
+    ),
+    showForm && /* @__PURE__ */ jsxs(Card, { className: "border-border-secondary bg-background-secondary", children: [
+      /* @__PURE__ */ jsx(CardHeader, { children: /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-3", children: [
+        /* @__PURE__ */ jsx("h3", { className: "font-medium text-text-primary", children: editingId ? tr(
+          "fluidgrids.settings.logStreaming.edit",
+          "Edit destination"
+        ) : tr(
+          "fluidgrids.settings.logStreaming.new",
+          "New destination"
+        ) }),
+        /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "sm", onClick: resetForm, children: /* @__PURE__ */ jsx(Icon, { icon: "mdi:close", width: 18 }) })
+      ] }) }),
+      /* @__PURE__ */ jsxs(CardContent, { className: "space-y-5", children: [
+        /* @__PURE__ */ jsxs("div", { className: "grid gap-4 md:grid-cols-2", children: [
+          /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "log-stream-name", children: tr("fluidgrids.settings.logStreaming.name", "Name") }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                id: "log-stream-name",
+                value: form.name,
+                onChange: (event) => setForm((current) => ({
+                  ...current,
+                  name: event.target.value
+                })),
+                placeholder: "Production error stream"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+            /* @__PURE__ */ jsx(Label, { htmlFor: "log-stream-provider", children: tr("fluidgrids.settings.logStreaming.provider", "Provider") }),
+            /* @__PURE__ */ jsx(
+              "select",
+              {
+                id: "log-stream-provider",
+                value: form.provider,
+                onChange: (event) => setForm((current) => ({
+                  ...current,
+                  provider: event.target.value,
+                  endpoint: ""
+                })),
+                className: "w-full rounded-md border border-border-secondary bg-background-primary px-3 py-2 text-sm text-text-primary",
+                children: PROVIDERS.map((provider) => /* @__PURE__ */ jsx("option", { value: provider, children: provider }, provider))
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "log-stream-endpoint", children: tr("fluidgrids.settings.logStreaming.endpoint", "Endpoint") }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "log-stream-endpoint",
+              value: form.endpoint,
+              onChange: (event) => setForm((current) => ({
+                ...current,
+                endpoint: event.target.value
+              })),
+              placeholder: endpointPlaceholder(form.provider),
+              type: form.provider === "WEBHOOK" || form.provider === "SENTRY" ? "url" : "text"
+            }
+          )
+        ] }),
+        form.provider === "WEBHOOK" && /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "log-stream-secret", children: tr(
+            "fluidgrids.settings.logStreaming.secret",
+            "Signing secret"
+          ) }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              id: "log-stream-secret",
+              value: form.secret,
+              onChange: (event) => setForm((current) => ({
+                ...current,
+                secret: event.target.value
+              })),
+              placeholder: editingId ? "Leave blank to keep the current secret" : "Enter a signing secret",
+              type: "password",
+              autoComplete: "new-password"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx(Label, { htmlFor: "log-stream-config", children: tr(
+            "fluidgrids.settings.logStreaming.config",
+            "Provider configuration (JSON)"
+          ) }),
+          /* @__PURE__ */ jsx(
+            "textarea",
+            {
+              id: "log-stream-config",
+              value: form.configText,
+              onChange: (event) => setForm((current) => ({
+                ...current,
+                configText: event.target.value
+              })),
+              className: "min-h-24 w-full rounded-md border border-border-secondary bg-background-primary px-3 py-2 font-mono text-xs text-text-primary",
+              spellCheck: false
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("fieldset", { className: "space-y-2", children: [
+          /* @__PURE__ */ jsx("legend", { className: "text-sm font-medium text-text-primary", children: tr(
+            "fluidgrids.settings.logStreaming.events",
+            "Events to stream"
+          ) }),
+          /* @__PURE__ */ jsx("div", { className: "grid gap-2 sm:grid-cols-2 lg:grid-cols-4", children: LOG_STREAM_EVENT_TYPES.map((event) => /* @__PURE__ */ jsxs(
+            "label",
+            {
+              className: "flex items-center gap-2 text-sm text-text-secondary",
+              children: [
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    type: "checkbox",
+                    checked: form.eventFilters.includes(event),
+                    onChange: () => toggleEvent(event),
+                    className: "size-4 rounded border-border-secondary accent-action-primary-bg"
+                  }
+                ),
+                eventLabel(event)
+              ]
+            },
+            event
+          )) })
+        ] }),
+        /* @__PURE__ */ jsxs("label", { className: "flex items-center gap-2 text-sm text-text-secondary", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "checkbox",
+              checked: form.isEnabled,
+              onChange: (event) => setForm((current) => ({
+                ...current,
+                isEnabled: event.target.checked
+              })),
+              className: "size-4 rounded border-border-secondary accent-action-primary-bg"
+            }
+          ),
+          tr(
+            "fluidgrids.settings.logStreaming.enabled",
+            "Destination enabled"
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-2", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: resetForm, children: tr("fluidgrids.settings.logStreaming.cancel", "Cancel") }),
+          /* @__PURE__ */ jsx(Button, { onClick: () => void save(), disabled: actions.loading, children: actions.loading ? tr("fluidgrids.settings.logStreaming.saving", "Saving\u2026") : tr(
+            "fluidgrids.settings.logStreaming.save",
+            "Save destination"
+          ) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+      loading && destinations.length === 0 && /* @__PURE__ */ jsx("div", { className: "rounded-lg border border-border-secondary bg-background-secondary p-6 text-sm text-text-secondary", children: tr(
+        "fluidgrids.settings.logStreaming.loading",
+        "Loading destinations\u2026"
+      ) }),
+      !loading && destinations.length === 0 && /* @__PURE__ */ jsxs("div", { className: "rounded-lg border border-dashed border-border-secondary bg-background-secondary p-8 text-center", children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            icon: "mdi:transit-connection-variant",
+            className: "mx-auto mb-3 text-text-secondary",
+            width: 32
+          }
+        ),
+        /* @__PURE__ */ jsx("p", { className: "font-medium text-text-primary", children: tr(
+          "fluidgrids.settings.logStreaming.emptyTitle",
+          "No log destinations yet"
+        ) }),
+        /* @__PURE__ */ jsx("p", { className: "mt-1 text-sm text-text-secondary", children: tr(
+          "fluidgrids.settings.logStreaming.emptyDescription",
+          "Add a webhook, syslog target, or Sentry DSN to start streaming events."
+        ) })
+      ] }),
+      destinations.map((destination) => /* @__PURE__ */ jsx(
+        Card,
+        {
+          className: "border-border-secondary bg-background-secondary",
+          children: /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-4 p-4 sm:flex-row sm:items-center sm:justify-between", children: [
+            /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [
+                /* @__PURE__ */ jsx("h3", { className: "font-medium text-text-primary", children: destination.name }),
+                /* @__PURE__ */ jsx("span", { className: "rounded-full bg-background-tertiary px-2 py-0.5 text-xs text-text-secondary", children: destination.provider }),
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    className: destination.isEnabled ? "text-xs text-status-success-text" : "text-xs text-text-secondary",
+                    children: destination.isEnabled ? tr(
+                      "fluidgrids.settings.logStreaming.enabledBadge",
+                      "Enabled"
+                    ) : tr(
+                      "fluidgrids.settings.logStreaming.disabledBadge",
+                      "Disabled"
+                    )
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx("p", { className: "mt-1 truncate text-sm text-text-secondary", children: destination.endpoint }),
+              /* @__PURE__ */ jsxs("p", { className: "mt-1 text-xs text-text-secondary", children: [
+                destination.eventFilters.length > 0 ? destination.eventFilters.map(eventLabel).join(", ") : tr(
+                  "fluidgrids.settings.logStreaming.allEvents",
+                  "All events"
+                ),
+                destination.hasSecret && " \xB7 Secret configured"
+              ] }),
+              destination.lastDispatchError && /* @__PURE__ */ jsx("p", { className: "mt-2 text-xs text-status-error-text", children: destination.lastDispatchError })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "flex shrink-0 flex-wrap gap-2", children: [
+              /* @__PURE__ */ jsxs(
+                Button,
+                {
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => void sendTest(destination),
+                  disabled: actions.loading,
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "mdi:send-check-outline",
+                        className: "mr-1",
+                        width: 15
+                      }
+                    ),
+                    tr("fluidgrids.settings.logStreaming.test", "Send test")
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  variant: "outline",
+                  size: "sm",
+                  onClick: () => {
+                    setEditingId(destination.id);
+                    setShowForm(true);
+                  },
+                  disabled: actions.loading,
+                  children: tr("fluidgrids.settings.logStreaming.editButton", "Edit")
+                }
+              ),
+              /* @__PURE__ */ jsxs(
+                Button,
+                {
+                  variant: "ghost",
+                  size: "sm",
+                  onClick: () => void remove(destination),
+                  disabled: actions.loading,
+                  children: [
+                    /* @__PURE__ */ jsx(
+                      Icon,
+                      {
+                        icon: "mdi:trash-can-outline",
+                        className: "text-status-error-text",
+                        width: 17
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("span", { className: "sr-only", children: tr("fluidgrids.settings.logStreaming.delete", "Delete") })
+                  ]
+                }
+              )
+            ] })
+          ] })
+        },
+        destination.id
+      ))
+    ] })
+  ] });
+}
+
+export { LogStreamingTab, useDataSinkData, useDataSinks, useInsightsData, useLogStreamDestinationActions, useLogStreamDestinations, useRunReplayActions };
+//# sourceMappingURL=chunk-5A7GP6O7.js.map
+//# sourceMappingURL=chunk-5A7GP6O7.js.map