@burdenoff/fluidgrids-fe-sdk 2026.1101.1 → 2026.1101.2

package/dist/{chunk-WNZV4SLU.js → chunk-4QHCXTHW.js}

@@ -1,8 +1,8 @@
-import { ActionPoliciesTab } from './chunk-AD7BICOT.js';
-import { LogStreamingTab } from './chunk-RIHYPPMQ.js';
-import { AgentsTab } from './chunk-YOLPHVOE.js';
+import { AgentsTab } from './chunk-YKFR7BZJ.js';
+import { ActionPoliciesTab } from './chunk-JKBCLBHY.js';
+import { LogStreamingTab } from './chunk-NLYQ3XDE.js';
 import { FluidGridsDocsLink } from './chunk-4VJ3MDOV.js';
-import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, throwIfResultError, describeOperationError, useConnections } from './chunk-6ILIBJFH.js';
+import { useFlowStore, useFluidGridsFlag, FLUIDGRIDS_FLAGS, useSaveStatusStore, findSaveConflict, useDurableParityEnabled, throwIfResultError, describeOperationError, useConnections } from './chunk-NZJWKVER.js';
 import { useFluidGridsPermission, FLUIDGRIDS_PERMISSIONS } from './chunk-ZUVFD5KV.js';
 import { getGlobalStoreClient } from './chunk-PXIFUMLA.js';
 import { getFluidGridsConfig } from './chunk-6AMNEX2Y.js';

package/dist/chunk-AASHQI77.js

@@ -0,0 +1,126 @@
+import { useBuilderReadOnly, toCodeMirrorDiagnostics } from './chunk-OCJTTHTS.js';
+import { useMemo, useRef, useEffect, useState } from 'react';
+import CodeMirror, { EditorView } from '@uiw/react-codemirror';
+import { lintGutter, setDiagnostics } from '@codemirror/lint';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsx } from 'react/jsx-runtime';
+
+function useLanguageExtension(language) {
+  const [extension, setExtension] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    const loaded = language === "python" ? import('@codemirror/lang-python').then((m) => m.python()) : import('@codemirror/lang-javascript').then(
+      (m) => m.javascript({ typescript: language === "typescript" })
+    );
+    void loaded.then((ext) => {
+      if (!cancelled) setExtension(ext);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [language]);
+  return extension;
+}
+function normalizeCodeLanguage(value) {
+  return typeof value === "string" && value.toLowerCase().startsWith("py") ? "python" : "javascript";
+}
+function useIsDarkTheme() {
+  const [dark, setDark] = useState(
+    () => typeof document !== "undefined" && document.documentElement.classList.contains("dark")
+  );
+  useEffect(() => {
+    const root = document.documentElement;
+    const observer = new MutationObserver(
+      () => setDark(root.classList.contains("dark"))
+    );
+    observer.observe(root, { attributes: true, attributeFilter: ["class"] });
+    return () => observer.disconnect();
+  }, []);
+  return dark;
+}
+function CodeEditorField({
+  value,
+  language,
+  placeholder,
+  label,
+  onChange,
+  readOnly: readOnlyProp = false,
+  diagnostics,
+  minHeight = "180px",
+  maxHeight = "420px",
+  className,
+  "data-testid": testId
+}) {
+  const dark = useIsDarkTheme();
+  const withLint = diagnostics !== void 0;
+  const builderReadOnly = useBuilderReadOnly();
+  const readOnly = readOnlyProp || builderReadOnly;
+  const languageExtension = useLanguageExtension(language);
+  const extensions = useMemo(
+    () => [
+      ...languageExtension ? [languageExtension] : [],
+      // CodeMirror's contenteditable is the control assistive tech focuses; name it.
+      ...label ? [EditorView.contentAttributes.of({ "aria-label": label })] : [],
+      ...withLint ? [lintGutter()] : []
+    ],
+    [languageExtension, label, withLint]
+  );
+  const viewRef = useRef(null);
+  useEffect(() => {
+    const view = viewRef.current;
+    if (!view || diagnostics === void 0) return;
+    view.dispatch(
+      setDiagnostics(
+        view.state,
+        toCodeMirrorDiagnostics(view.state.doc.toString(), diagnostics)
+      )
+    );
+  }, [diagnostics]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-testid": testId,
+      className: cn(
+        "overflow-hidden rounded-md border border-input text-sm transition-colors focus-within:border-primary",
+        className
+      ),
+      onKeyDown: (e) => e.stopPropagation(),
+      onMouseDown: (e) => e.stopPropagation(),
+      children: /* @__PURE__ */ jsx(
+        CodeMirror,
+        {
+          value,
+          onChange: readOnly ? void 0 : onChange,
+          extensions,
+          theme: dark ? "dark" : "light",
+          placeholder,
+          minHeight,
+          maxHeight,
+          editable: !readOnly,
+          readOnly,
+          onCreateEditor: (view) => {
+            viewRef.current = view;
+            if (diagnostics?.length)
+              view.dispatch(
+                setDiagnostics(
+                  view.state,
+                  toCodeMirrorDiagnostics(view.state.doc.toString(), diagnostics)
+                )
+              );
+          },
+          basicSetup: {
+            lineNumbers: true,
+            foldGutter: true,
+            highlightActiveLine: !readOnly,
+            autocompletion: !readOnly,
+            bracketMatching: true,
+            closeBrackets: !readOnly,
+            indentOnInput: !readOnly
+          }
+        }
+      )
+    }
+  );
+}
+
+export { CodeEditorField, normalizeCodeLanguage };

package/dist/chunk-CGXQVZGY.js

@@ -0,0 +1,260 @@
+import { throwIfResultError } from './chunk-NZJWKVER.js';
+import { useTr } from './chunk-UULVIT25.js';
+import { getFluidGridsClient } from './chunk-NTWG3CJX.js';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { gql } from '@apollo/client';
+import { cn } from '@burdenoff/fe-libs/utils';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '@burdenoff/fe-libs/ui';
+
+var RUNNER_FIELDS = gql`
+  fragment SandboxRunnerFields on SandboxRunner {
+    id
+    name
+    status
+    hostname
+    os
+    arch
+    driver
+    version
+    capacity
+    privateNetwork {
+      target
+      ports
+      nodes
+    }
+    tokenPrefix
+    lastSeenAt
+    connectedAt
+    createdBy
+    createdAt
+  }
+`;
+var LIST_RUNNERS = gql`
+  ${RUNNER_FIELDS}
+  query SandboxRunners {
+    sandboxRunners(context: {}) {
+      ...SandboxRunnerFields
+    }
+  }
+`;
+var CREATE_RUNNER = gql`
+  ${RUNNER_FIELDS}
+  mutation CreateSandboxRunner($name: String!) {
+    createSandboxRunner(input: { name: $name, context: {} }) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+var ROTATE_RUNNER_TOKEN = gql`
+  ${RUNNER_FIELDS}
+  mutation RotateSandboxRunnerToken($id: ID!) {
+    rotateSandboxRunnerToken(id: $id, context: {}) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+var DELETE_RUNNER = gql`
+  mutation DeleteSandboxRunner($id: ID!) {
+    deleteSandboxRunner(id: $id, context: {})
+  }
+`;
+var RUNNER_INSTALL_SCRIPT_URL = "https://www.fluidgrids.ai/downloads/runner/install.sh";
+function runnerInstallCommand(bridgeUrl) {
+  const base = `curl -fsSL ${RUNNER_INSTALL_SCRIPT_URL} | sh`;
+  return bridgeUrl && bridgeUrl !== DEFAULT_BRIDGE_URL ? `${base} -s -- --url ${bridgeUrl}` : base;
+}
+var DEFAULT_BRIDGE_URL = "wss://graphqlworkspaces.burdenoff.com/runner-bridge";
+function useRunners(options) {
+  const [runners, setRunners] = useState([]);
+  const [loading, setLoading] = useState(!options?.skip);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  const fetchRunners = useCallback(async () => {
+    if (options?.skip) return;
+    try {
+      const result = await getFluidGridsClient().query({ query: LIST_RUNNERS, fetchPolicy: "network-only" });
+      if (!mounted.current) return;
+      setRunners(result.data?.sandboxRunners ?? []);
+      setError(null);
+    } catch (err) {
+      if (mounted.current) setError(err);
+    } finally {
+      if (mounted.current) setLoading(false);
+    }
+  }, [options?.skip]);
+  useEffect(() => {
+    mounted.current = true;
+    void fetchRunners();
+    const pollMs = options?.pollMs ?? 1e4;
+    const timer = pollMs > 0 ? setInterval(fetchRunners, pollMs) : null;
+    return () => {
+      mounted.current = false;
+      if (timer) clearInterval(timer);
+    };
+  }, [fetchRunners, options?.pollMs]);
+  return { runners, loading, error, refetch: fetchRunners };
+}
+function useRunnerActions() {
+  const [busy, setBusy] = useState(false);
+  const run = useCallback(async (fn) => {
+    setBusy(true);
+    try {
+      return await fn();
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const createRunner = useCallback(
+    (name) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: CREATE_RUNNER, variables: { name } })
+      );
+      if (!result.data?.createSandboxRunner)
+        throw new Error("No runner returned");
+      return result.data.createSandboxRunner;
+    }),
+    [run]
+  );
+  const rotateToken = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({ mutation: ROTATE_RUNNER_TOKEN, variables: { id } })
+      );
+      if (!result.data?.rotateSandboxRunnerToken)
+        throw new Error("No runner returned");
+      return result.data.rotateSandboxRunnerToken;
+    }),
+    [run]
+  );
+  const deleteRunner = useCallback(
+    (id) => run(async () => {
+      const result = throwIfResultError(
+        await getFluidGridsClient().mutate({
+          mutation: DELETE_RUNNER,
+          variables: { id }
+        })
+      );
+      return result.data?.deleteSandboxRunner === true;
+    }),
+    [run]
+  );
+  return { createRunner, rotateToken, deleteRunner, busy };
+}
+var STYLES = {
+  ONLINE: "border-status-success-border bg-status-success-bg-subtle text-status-success-text",
+  OFFLINE: "border-border-default bg-bg-sunken text-text-muted",
+  NEVER_CONNECTED: "border-status-warning-border bg-status-warning-bg-subtle text-status-warning-text"
+};
+function RunnerStatusPill({
+  status,
+  className
+}) {
+  const tr = useTr();
+  const label = status === "ONLINE" ? tr("fluidgrids.runners.online", "Online") : status === "OFFLINE" ? tr("fluidgrids.runners.offline", "Offline") : tr("fluidgrids.runners.neverConnected", "Not connected yet");
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn(
+        "inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-medium",
+        STYLES[status],
+        className
+      ),
+      "data-testid": "runner-status",
+      "data-status": status,
+      children: label
+    }
+  );
+}
+var CLOUD = "__fluidgrids_cloud__";
+function RunOnSection({
+  value,
+  onChange,
+  sectionLabelClassName
+}) {
+  const tr = useTr();
+  const { runners, loading } = useRunners({ pollMs: 15e3 });
+  const selected = value ? runners.find((r) => r.id === value.runnerId) : void 0;
+  return /* @__PURE__ */ jsxs("section", { className: "space-y-2", "data-testid": "ndv-settings-run-on", children: [
+    /* @__PURE__ */ jsx("div", { className: sectionLabelClassName, children: tr("fluidgrids.builder.nodeSettings.runOn", "Run on") }),
+    /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: value?.runnerId ?? CLOUD,
+        onValueChange: (v) => onChange(v === CLOUD ? null : { kind: "runner", runnerId: v }),
+        children: [
+          /* @__PURE__ */ jsx(
+            SelectTrigger,
+            {
+              className: "w-full",
+              "data-testid": "ndv-settings-run-on-select",
+              children: /* @__PURE__ */ jsx(SelectValue, {})
+            }
+          ),
+          /* @__PURE__ */ jsxs(
+            SelectContent,
+            {
+              style: { zIndex: 1100 },
+              "data-testid": "ndv-settings-run-on-options",
+              children: [
+                /* @__PURE__ */ jsx(SelectItem, { value: CLOUD, "data-testid": "run-on-cloud", children: tr(
+                  "fluidgrids.builder.nodeSettings.runOnCloud",
+                  "FluidGrids Cloud (default)"
+                ) }),
+                runners.map((runner) => /* @__PURE__ */ jsxs(
+                  SelectItem,
+                  {
+                    value: runner.id,
+                    "data-testid": "run-on-runner-option",
+                    children: [
+                      runner.name,
+                      runner.status !== "ONLINE" ? ` (${runner.status === "OFFLINE" ? tr("fluidgrids.runners.offline", "Offline") : tr("fluidgrids.runners.neverConnected", "Not connected yet")})` : ""
+                    ]
+                  },
+                  runner.id
+                )),
+                value && !loading && !selected && /* @__PURE__ */ jsx(SelectItem, { value: value.runnerId, disabled: true, children: tr(
+                  "fluidgrids.builder.nodeSettings.runOnMissing",
+                  "Removed runner"
+                ) })
+              ]
+            }
+          )
+        ]
+      }
+    ),
+    value ? /* @__PURE__ */ jsxs("div", { className: "space-y-1 text-xs text-text-secondary", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-2", children: [
+        selected && /* @__PURE__ */ jsx(RunnerStatusPill, { status: selected.status }),
+        /* @__PURE__ */ jsx("span", { children: tr(
+          "fluidgrids.builder.nodeSettings.runOnRunnerHint",
+          "This node runs on your runner, in a local sandbox. If the runner is offline the node fails \u2014 it never falls back to FluidGrids Cloud. The node's input and the credentials it uses are sent to that machine."
+        ) })
+      ] }),
+      selected && /* @__PURE__ */ jsx("p", { "data-testid": "run-on-private-network", children: (selected.privateNetwork ?? []).length === 0 ? tr(
+        "fluidgrids.builder.nodeSettings.runOnPublicOnly",
+        "On this runner, nodes reach the public internet only. Private destinations are opened on the runner machine (fluidgrids-runner network allow)."
+      ) : tr(
+        "fluidgrids.builder.nodeSettings.runOnPrivateNetwork",
+        "This runner opens {{count}} private destination(s) \u2014 see Runners for which nodes may use them.",
+        { count: (selected.privateNetwork ?? []).length }
+      ) })
+    ] }) : /* @__PURE__ */ jsx("p", { className: "text-xs text-text-secondary", children: runners.length === 0 && !loading ? tr(
+      "fluidgrids.builder.nodeSettings.runOnNoRunners",
+      "Runs in FluidGrids Cloud. Add a runner under Workflows \u2192 Runners to run nodes on your own machine."
+    ) : tr(
+      "fluidgrids.builder.nodeSettings.runOnCloudHint",
+      "Runs in FluidGrids Cloud."
+    ) })
+  ] });
+}
+
+export { RUNNER_INSTALL_SCRIPT_URL, RunOnSection, RunnerStatusPill, runnerInstallCommand, useRunnerActions, useRunners };

package/dist/chunk-CRDG2SQQ.js

@@ -0,0 +1,185 @@
+import { STICKY_NOTE_TYPE, isNodeTrigger, isLocked, useEditLeaseStore, useSaveStatusStore, canAutosave, editStateOf, workflowFingerprint, snapshotForSave, leaveNeedsConfirmation, runPreparationOf, useFlowStore, resolveInputHandles } from './chunk-NZJWKVER.js';
+import { getConnectedEdges, useReactFlow } from '@xyflow/react';
+import { useState, useCallback } from 'react';
+
+function findEdges(node, connectedEdges) {
+  const outgoingEdges = connectedEdges.filter(
+    (edge) => edge.source === node.id
+  );
+  const incomingEdges = connectedEdges.filter(
+    (edge) => edge.target === node.id
+  );
+  return { outgoingEdges, incomingEdges };
+}
+function checkFlowTerminalNode(outgoingEdges, incomingEdges, isTrigger, type) {
+  if (isTrigger) {
+    return outgoingEdges.length >= 1;
+  }
+  switch (type) {
+    case "end" /* END */:
+      return incomingEdges.length >= 1;
+    default:
+      return false;
+  }
+}
+function checkLoneNode(outgoingEdges, incomingEdges, isTrigger) {
+  if (isTrigger) {
+    return outgoingEdges.length === 0;
+  }
+  return incomingEdges.length === 0;
+}
+function isFlowComplete(nodes, edges) {
+  const connectedEdges = getConnectedEdges(nodes, edges);
+  let isTriggerConnected = false;
+  let hasTriggerNode = false;
+  let hasEndNode = false;
+  let isEndConnected = false;
+  const nodesWithEmptyTarget = [];
+  for (const node of nodes) {
+    if (node.type === STICKY_NOTE_TYPE) continue;
+    const { outgoingEdges, incomingEdges } = findEdges(node, connectedEdges);
+    const isTrigger = isNodeTrigger(node);
+    if (isTrigger) {
+      hasTriggerNode = true;
+      if (checkFlowTerminalNode(
+        outgoingEdges,
+        incomingEdges,
+        true,
+        node.type
+      )) {
+        isTriggerConnected = true;
+      }
+    } else if (node.type === "end" /* END */) {
+      hasEndNode = true;
+      isEndConnected = checkFlowTerminalNode(
+        outgoingEdges,
+        incomingEdges,
+        false,
+        "end" /* END */
+      );
+    }
+    if (checkLoneNode(outgoingEdges, incomingEdges, isTrigger))
+      nodesWithEmptyTarget.push(node);
+  }
+  const hasAnyLoneNode = nodesWithEmptyTarget.length > 0;
+  const isEndValid = !hasEndNode || isEndConnected;
+  return hasTriggerNode && isTriggerConnected && isEndValid && !hasAnyLoneNode;
+}
+function useFlowValidator(onValidate) {
+  const [isValidating, setIsValidating] = useState(false);
+  const { getNodes, getEdges } = useReactFlow();
+  const validate = useCallback(async () => {
+    setIsValidating(true);
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    onValidate?.(isFlowComplete(getNodes(), getEdges()));
+    setIsValidating(false);
+  }, [getNodes, getEdges, onValidate]);
+  return [isValidating, validate];
+}
+
+// src/builder/lib/save-guards.ts
+function editingLeaseLocked() {
+  return isLocked(useEditLeaseStore.getState().phase);
+}
+function autosaveAllowedFor(workflow) {
+  return useSaveStatusStore.getState().autosaveEnabled && canAutosave(workflow);
+}
+function editStateFor(state) {
+  return editStateOf(
+    useSaveStatusStore.getState().baseline,
+    {
+      fingerprint: workflowFingerprint(state.workflow),
+      generation: state.loadGeneration,
+      editRevision: state.editRevision
+    },
+    Date.now()
+  );
+}
+function departingSave(state) {
+  const status = useSaveStatusStore.getState();
+  if (status.autosavePaused || editingLeaseLocked()) return null;
+  if (editStateFor(state) !== "dirty") return null;
+  if (!autosaveAllowedFor(state.workflow)) return null;
+  const { nodes, edges } = state.workflow;
+  if (!isFlowComplete(nodes, edges)) return null;
+  return snapshotForSave(state.workflow, state.loadGeneration);
+}
+function touchesSavedFields(state, previous) {
+  return state.workflow.nodes !== previous.workflow.nodes || state.workflow.edges !== previous.workflow.edges || state.workflow.name !== previous.workflow.name || state.workflow.alias !== previous.workflow.alias || state.workflow.status !== previous.workflow.status || state.loadGeneration !== previous.loadGeneration;
+}
+function unsavedState() {
+  const flow = useFlowStore.getState();
+  const status = useSaveStatusStore.getState();
+  return {
+    // Checked fresh: the dirty flag trails the last edit by a moment.
+    dirty: status.dirty || editStateFor(flow) === "dirty",
+    // A paused autosave (a refused save), or a page someone else is editing
+    // from, does not save on the way out either.
+    autosaveAllowed: autosaveAllowedFor(flow.workflow) && !status.autosavePaused && !editingLeaseLocked(),
+    incomplete: status.incomplete || !isFlowComplete(flow.workflow.nodes, flow.workflow.edges),
+    failed: status.failure !== null
+  };
+}
+function leavingLosesChanges() {
+  return leaveNeedsConfirmation(unsavedState());
+}
+function runPreparation() {
+  return runPreparationOf(unsavedState());
+}
+function savedEverythingBeforeLeaving() {
+  return editStateFor(useFlowStore.getState()) !== "dirty";
+}
+function watchLeavingLosesChanges(onChange, delayMs) {
+  let current;
+  let timer;
+  const report = (losesChanges) => {
+    if (losesChanges === current) return;
+    current = losesChanges;
+    onChange(losesChanges);
+  };
+  const settle = () => {
+    timer = void 0;
+    report(leavingLosesChanges());
+  };
+  const settleLater = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(settle, delayMs);
+  };
+  const settleNow = () => {
+    if (timer) clearTimeout(timer);
+    settle();
+  };
+  settle();
+  const unsubscribeFlow = useFlowStore.subscribe((state, previous) => {
+    if (!touchesSavedFields(state, previous)) return;
+    if (state.loadGeneration === previous.loadGeneration) report(true);
+    settleLater();
+  });
+  const unsubscribeStatus = useSaveStatusStore.subscribe(settleLater);
+  const unsubscribeLease = useEditLeaseStore.subscribe((state, previous) => {
+    if (isLocked(state.phase) !== isLocked(previous.phase)) settleNow();
+  });
+  return () => {
+    unsubscribeFlow();
+    unsubscribeStatus();
+    unsubscribeLease();
+    if (timer) clearTimeout(timer);
+  };
+}
+
+// src/builder/hooks/attach-node-helpers.ts
+var ATTACH_GAP_X = 120;
+var DEFAULT_NODE_WIDTH = 288;
+function computeAttachPosition(source) {
+  if (!source) return void 0;
+  const width = source.measured?.width ?? DEFAULT_NODE_WIDTH;
+  return {
+    x: source.position.x + width + ATTACH_GAP_X,
+    y: source.position.y
+  };
+}
+function firstInputHandleId(data) {
+  return resolveInputHandles(data)[0]?.id ?? "target";
+}
+
+export { autosaveAllowedFor, computeAttachPosition, departingSave, editStateFor, editingLeaseLocked, firstInputHandleId, isFlowComplete, leavingLosesChanges, runPreparation, savedEverythingBeforeLeaving, touchesSavedFields, useFlowValidator, watchLeavingLosesChanges };