@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.17

package/dist/RunnerStatusPill-Ctg4TJcP.js

@@ -0,0 +1,187 @@
+"use client";
+import { _ as throwIfResultError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { cn } from "@burdenoff/fe-libs/utils";
+import { jsx } from "react/jsx-runtime";
+import { gql } from "@apollo/client";
+
+// src/modules/runners/hooks/useRunners.ts
+/**
+* Self-hosted runners (wspace-sandbox-svc): list, add, rotate token, remove.
+*
+* A runner is a program the customer installs on their own machine; workflow
+* nodes whose "Run on" names it execute there, in a local sandbox. Mirrors the
+* connections/variables hook pattern (shared Apollo client, no generated hooks).
+*/
+const 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
+  }
+`;
+const LIST_RUNNERS = gql`
+  ${RUNNER_FIELDS}
+  query SandboxRunners {
+    sandboxRunners(context: {}) {
+      ...SandboxRunnerFields
+    }
+  }
+`;
+const CREATE_RUNNER = gql`
+  ${RUNNER_FIELDS}
+  mutation CreateSandboxRunner($name: String!) {
+    createSandboxRunner(input: { name: $name, context: {} }) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+const ROTATE_RUNNER_TOKEN = gql`
+  ${RUNNER_FIELDS}
+  mutation RotateSandboxRunnerToken($id: ID!) {
+    rotateSandboxRunnerToken(id: $id, context: {}) {
+      token
+      bridgeUrl
+      runner {
+        ...SandboxRunnerFields
+      }
+    }
+  }
+`;
+const DELETE_RUNNER = gql`
+  mutation DeleteSandboxRunner($id: ID!) {
+    deleteSandboxRunner(id: $id, context: {})
+  }
+`;
+/** Where the installer is published (fluidgrids-runner release workflow). */
+const RUNNER_INSTALL_SCRIPT_URL = "https://www.fluidgrids.ai/downloads/runner/install.sh";
+/**
+* The one-line install command shown after creating a runner. It carries NO
+* token: the installer asks for it (input hidden), so the token never lands in
+* shell history or the machine's process list.
+*/
+function runnerInstallCommand(bridgeUrl) {
+	const base = `curl -fsSL ${RUNNER_INSTALL_SCRIPT_URL} | sh`;
+	return bridgeUrl && bridgeUrl !== "wss://graphqlworkspaces.burdenoff.com/runner-bridge" ? `${base} -s -- --url ${bridgeUrl}` : base;
+}
+/** The runner's built-in default; omitted from the command when it matches. */
+const DEFAULT_BRIDGE_URL = "wss://graphqlworkspaces.burdenoff.com/runner-bridge";
+/**
+* Runners in the current workspace. Polls while mounted so ONLINE/OFFLINE
+* stays current (a runner heartbeats every 20 s).
+*/
+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;
+		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);
+		}
+	}, []);
+	return {
+		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]),
+		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]),
+		deleteRunner: useCallback((id) => run(async () => {
+			return throwIfResultError(await getFluidGridsClient().mutate({
+				mutation: DELETE_RUNNER,
+				variables: { id }
+			})).data?.deleteSandboxRunner === true;
+		}), [run]),
+		busy
+	};
+}
+
+// src/modules/runners/components/RunnerStatusPill.tsx
+const 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"
+};
+/** Online / Offline / Not connected yet. */
+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
+	});
+}
+
+export { useRunners as a, useRunnerActions as i, RUNNER_INSTALL_SCRIPT_URL as n, runnerInstallCommand as r, RunnerStatusPill as t };

package/dist/RunnersPage-CLCOCclc.js

@@ -0,0 +1,467 @@
+"use client";
+import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { i as SdkPermissionButton, t as FLUIDGRIDS_PERMISSIONS } from "./constants-B2lhWNoN.js";
+import { a as useRunners, i as useRunnerActions, r as runnerInstallCommand, t as RunnerStatusPill } from "./RunnerStatusPill-Ctg4TJcP.js";
+import { t as FluidGridsDocsLink } from "./FluidGridsDocsLink-JxkBpOeb.js";
+import { useCallback, useEffect, useState } from "react";
+import { Icon } from "@iconify/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { toast } from "sonner";
+import { Badge, Card, CardHeader, Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle, Input, Label, Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@burdenoff/fe-libs/ui";
+import { Button as Button$1 } from "@burdenoff/fe-libs/button";
+
+// src/modules/runners/pages/RunnersPage.tsx
+/**
+* Runners Page — self-hosted runners.
+*
+* A runner is a small program a customer installs on their own VM or laptop.
+* It connects out to FluidGrids, and any workflow node whose Settings →
+* "Run on" names it executes on that machine, inside a local sandbox.
+*
+* Adding a runner issues a token that is shown ONCE, inside a ready-to-paste
+* install command; the dialog then waits for the runner to come online.
+*/
+var RunnersPage_exports = /* @__PURE__ */ __exportAll({
+	RunnersPage: () => RunnersPage,
+	describePrivateRule: () => describePrivateRule
+});
+function formatSeen(iso) {
+	if (!iso) return "—";
+	const seconds = Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 1e3));
+	if (seconds < 60) return `${seconds}s ago`;
+	if (seconds < 3600) return `${Math.round(seconds / 60)}m ago`;
+	if (seconds < 86400) return `${Math.round(seconds / 3600)}h ago`;
+	return new Date(iso).toLocaleDateString();
+}
+/** Rules shown inline before folding the rest behind "+N more". */
+const PRIVATE_NETWORK_INLINE = 3;
+/** "10.0.5.12:5432" / "db.corp (all ports)" for one rule. */
+function describePrivateRule(rule, allPorts) {
+	return rule.ports.length > 0 ? `${rule.target}:${rule.ports.join(",")}` : `${rule.target} (${allPorts})`;
+}
+/**
+* What a runner's nodes may reach besides the public internet. Read-only: the
+* list is set on the runner machine (`fluidgrids-runner network allow`), never
+* here, so a FluidGrids account cannot open a path into the customer's network.
+*/
+function PrivateNetworkCell({ rules }) {
+	const tr = useTr();
+	const [expanded, setExpanded] = useState(false);
+	if (rules.length === 0) return /* @__PURE__ */ jsx("span", {
+		"data-testid": "runner-private-network-none",
+		children: tr("fluidgrids.runners.publicOnly", "Public internet only")
+	});
+	const allPorts = tr("fluidgrids.runners.allPorts", "all ports");
+	const everyNode = tr("fluidgrids.runners.everyNode", "every node");
+	const hidden = rules.length - PRIVATE_NETWORK_INLINE;
+	const shown = expanded || hidden <= 0 ? rules : rules.slice(0, PRIVATE_NETWORK_INLINE);
+	return /* @__PURE__ */ jsxs("div", {
+		"data-testid": "runner-private-network",
+		children: [/* @__PURE__ */ jsx("ul", {
+			className: "space-y-0.5",
+			children: shown.map((rule, index) => /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("span", {
+				className: "font-mono text-xs text-text-primary",
+				children: describePrivateRule(rule, allPorts)
+			}), /* @__PURE__ */ jsx("span", {
+				className: "ml-1 text-xs",
+				children: rule.nodes.length > 0 ? rule.nodes.join(", ") : everyNode
+			})] }, `${rule.target}-${index}`))
+		}), hidden > 0 && /* @__PURE__ */ jsx(Button$1, {
+			variant: "link",
+			size: "sm",
+			className: "h-auto p-0 text-xs",
+			"aria-expanded": expanded,
+			onClick: () => setExpanded((open) => !open),
+			"data-testid": "runner-private-network-toggle",
+			children: expanded ? tr("fluidgrids.runners.showFewer", "Show fewer") : tr("fluidgrids.runners.moreRules", "+{{count}} more", { count: hidden })
+		})]
+	});
+}
+/** Install command + copy button, with the "shown once" warning. */
+function CopyableValue({ value, copied, testId, copyTestId }) {
+	const tr = useTr();
+	const copy = useCallback(async () => {
+		try {
+			await navigator.clipboard.writeText(value);
+			toast.success(copied);
+		} catch {
+			toast.error(tr("fluidgrids.runners.copyFailed", "Could not copy — select the text and copy it manually"));
+		}
+	}, [
+		value,
+		copied,
+		tr
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex items-start gap-2",
+		children: [/* @__PURE__ */ jsx("pre", {
+			className: "flex-1 overflow-x-auto whitespace-pre-wrap break-all rounded-md border border-border bg-muted p-3 font-mono text-xs",
+			"data-testid": testId,
+			children: value
+		}), /* @__PURE__ */ jsxs(Button$1, {
+			variant: "outline",
+			size: "sm",
+			onClick: copy,
+			"data-testid": copyTestId,
+			children: [/* @__PURE__ */ jsx(Icon, {
+				icon: "lucide:copy",
+				className: "mr-1 h-4 w-4"
+			}), tr("fluidgrids.runners.copy", "Copy")]
+		})]
+	});
+}
+/**
+* Install command + token, kept apart: the command carries no token, and the
+* installer asks for it with hidden input — so the token never lands in shell
+* history or the machine's process list.
+*/
+function InstallCommand({ issued }) {
+	const tr = useTr();
+	const command = runnerInstallCommand(issued.bridgeUrl);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-3",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "space-y-2",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "text-sm text-text-secondary",
+					children: tr("fluidgrids.runners.installHint", "1. Run this on the machine that should run your nodes (Linux, or a Mac with Apple silicon). It installs the runner and its sandbox, and starts it in the background.")
+				}), /* @__PURE__ */ jsx(CopyableValue, {
+					value: command,
+					copied: tr("fluidgrids.runners.copied", "Install command copied"),
+					testId: "runner-install-command",
+					copyTestId: "runner-copy-command"
+				})]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "space-y-2",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "text-sm text-text-secondary",
+					children: tr("fluidgrids.runners.tokenHint", "2. Paste this token when the installer asks for it. It is not part of the command, so it never ends up in your shell history.")
+				}), /* @__PURE__ */ jsx(CopyableValue, {
+					value: issued.token,
+					copied: tr("fluidgrids.runners.tokenCopied", "Token copied"),
+					testId: "runner-token",
+					copyTestId: "runner-copy-token"
+				})]
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "text-xs text-status-warning-text",
+				children: tr("fluidgrids.runners.tokenOnce", "The token is shown only once. Rotate it from the runner list if it is lost.")
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "text-xs text-text-secondary",
+				children: tr("fluidgrids.runners.tokenAutomation", "Installing without a terminal (cloud-init, scripts)? Save the token to a file only you can read and add --token-file <path> to the command.")
+			})
+		]
+	});
+}
+/** Add-runner dialog: name → command → waits for the runner to connect. */
+function AddRunnerDialog({ open, onOpenChange, runners, onCreated }) {
+	const tr = useTr();
+	const { createRunner, busy } = useRunnerActions();
+	const [name, setName] = useState("");
+	const [issued, setIssued] = useState(null);
+	useEffect(() => {
+		if (!open) {
+			setName("");
+			setIssued(null);
+		}
+	}, [open]);
+	const live = issued ? runners.find((r) => r.id === issued.runner.id) : void 0;
+	const submit = useCallback(async () => {
+		try {
+			setIssued(await createRunner(name.trim()));
+			onCreated();
+		} catch (err) {
+			toast.error(err instanceof Error ? err.message : tr("fluidgrids.runners.createFailed", "Could not add the runner"));
+		}
+	}, [
+		createRunner,
+		name,
+		onCreated,
+		tr
+	]);
+	return /* @__PURE__ */ jsx(Dialog, {
+		open,
+		onOpenChange,
+		children: /* @__PURE__ */ jsxs(DialogContent, {
+			className: "sm:max-w-2xl",
+			"data-testid": "add-runner-dialog",
+			children: [
+				/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runners.addTitle", "Add a runner") }) }),
+				!issued ? /* @__PURE__ */ jsxs("div", {
+					className: "space-y-2",
+					children: [/* @__PURE__ */ jsx(Label, {
+						htmlFor: "runner-name",
+						children: tr("fluidgrids.runners.name", "Name")
+					}), /* @__PURE__ */ jsx(Input, {
+						id: "runner-name",
+						value: name,
+						maxLength: 100,
+						placeholder: tr("fluidgrids.runners.namePlaceholder", "e.g. build-server or my-laptop"),
+						onChange: (e) => setName(e.target.value),
+						onKeyDown: (e) => {
+							if (e.key === "Enter" && name.trim()) submit();
+						},
+						"data-testid": "runner-name-input"
+					})]
+				}) : /* @__PURE__ */ jsxs("div", {
+					className: "space-y-4",
+					children: [/* @__PURE__ */ jsx(InstallCommand, { issued }), /* @__PURE__ */ jsx("div", {
+						className: "flex items-center gap-2 text-sm",
+						"data-testid": "runner-connect-status",
+						children: live?.status === "ONLINE" ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "lucide:check-circle-2",
+							className: "h-4 w-4 text-status-success-text"
+						}), tr("fluidgrids.runners.connected", "Connected. You can now pick this runner in a node's Settings → Run on.")] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "lucide:loader-2",
+							className: "h-4 w-4 animate-spin text-text-secondary"
+						}), tr("fluidgrids.runners.waiting", "Waiting for the runner to connect…")] })
+					})]
+				}),
+				/* @__PURE__ */ jsx(DialogFooter, { children: !issued ? /* @__PURE__ */ jsx(Button$1, {
+					onClick: submit,
+					disabled: busy || !name.trim(),
+					"data-testid": "runner-create-submit",
+					children: tr("fluidgrids.runners.create", "Create runner")
+				}) : /* @__PURE__ */ jsx(Button$1, {
+					variant: "outline",
+					onClick: () => onOpenChange(false),
+					"data-testid": "runner-dialog-done",
+					children: tr("fluidgrids.runners.done", "Done")
+				}) })
+			]
+		})
+	});
+}
+function RunnersPage() {
+	const tr = useTr();
+	const { runners, loading, error, refetch } = useRunners({ pollMs: 5e3 });
+	const { rotateToken, deleteRunner, busy } = useRunnerActions();
+	const [adding, setAdding] = useState(false);
+	const [rotated, setRotated] = useState(null);
+	const [removing, setRemoving] = useState(null);
+	const handleRotate = useCallback(async (runner) => {
+		try {
+			setRotated(await rotateToken(runner.id));
+			refetch();
+		} catch (err) {
+			toast.error(err instanceof Error ? err.message : tr("fluidgrids.runners.rotateFailed", "Could not rotate the token"));
+		}
+	}, [
+		refetch,
+		rotateToken,
+		tr
+	]);
+	const handleRemove = useCallback(async () => {
+		if (!removing) return;
+		try {
+			await deleteRunner(removing.id);
+			toast.success(tr("fluidgrids.runners.removed", "Runner removed"));
+			setRemoving(null);
+			refetch();
+		} catch (err) {
+			toast.error(err instanceof Error ? err.message : tr("fluidgrids.runners.removeFailed", "Could not remove the runner"));
+		}
+	}, [
+		deleteRunner,
+		refetch,
+		removing,
+		tr
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-6 p-6",
+		"data-testid": "runners-page",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-start justify-between gap-4",
+				"data-tour": "fluidgrids-runners-header",
+				children: [/* @__PURE__ */ jsxs("div", { children: [
+					/* @__PURE__ */ jsx("h1", {
+						className: "text-2xl font-semibold text-text-primary",
+						children: tr("fluidgrids.runners.title", "Runners")
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "mt-1 max-w-2xl text-sm text-text-secondary",
+						children: tr("fluidgrids.runners.subtitle", "Run workflow nodes on your own machines. A node set to Run on a runner executes there, inside a local sandbox; the rest of the workflow keeps running in FluidGrids.")
+					}),
+					/* @__PURE__ */ jsxs("p", {
+						className: "mt-1 max-w-2xl text-sm text-text-secondary",
+						"data-testid": "runners-private-network-hint",
+						children: [
+							tr("fluidgrids.runners.privateNetworkHint", "Nodes reach the public internet only. To let them reach something inside your network, open it on the runner machine:"),
+							" ",
+							/* @__PURE__ */ jsx("code", {
+								className: "rounded bg-muted px-1 font-mono text-xs text-text-primary",
+								children: "fluidgrids-runner network allow 10.0.5.12 --port 5432"
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(FluidGridsDocsLink, {
+						topic: "runners",
+						className: "mt-1"
+					})
+				] }), /* @__PURE__ */ jsx(SdkPermissionButton, {
+					permission: FLUIDGRIDS_PERMISSIONS.SANDBOX_CREATE,
+					deniedTooltip: tr("fluidgrids.runners.addDeniedTooltip", "You don't have permission to add runners"),
+					children: /* @__PURE__ */ jsxs(Button$1, {
+						onClick: () => setAdding(true),
+						"data-testid": "runner-add",
+						"data-tour": "fluidgrids-runners-add",
+						children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "lucide:plus",
+							className: "mr-1 h-4 w-4"
+						}), tr("fluidgrids.runners.add", "Add runner")]
+					})
+				})]
+			}),
+			error && /* @__PURE__ */ jsx("div", {
+				className: "rounded-md border border-status-error-border bg-status-error-bg-subtle p-3 text-sm text-status-error-text",
+				children: error.message
+			}),
+			/* @__PURE__ */ jsx(Card, {
+				"data-tour": "fluidgrids-runners-table",
+				children: /* @__PURE__ */ jsx(CardHeader, {
+					className: "p-0",
+					children: /* @__PURE__ */ jsxs(Table, { children: [/* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.name", "Name") }),
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.status", "Status") }),
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.machine", "Machine") }),
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.sandbox", "Sandbox") }),
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.privateNetwork", "Private network") }),
+						/* @__PURE__ */ jsx(TableHead, { children: tr("fluidgrids.runners.lastSeen", "Last seen") }),
+						/* @__PURE__ */ jsx(TableHead, {
+							className: "text-right",
+							children: tr("fluidgrids.runners.actions", "Actions")
+						})
+					] }) }), /* @__PURE__ */ jsxs(TableBody, { children: [runners.map((runner) => /* @__PURE__ */ jsxs(TableRow, {
+						"data-testid": "runner-row",
+						children: [
+							/* @__PURE__ */ jsxs(TableCell, { children: [/* @__PURE__ */ jsx("div", {
+								className: "font-medium text-text-primary",
+								children: runner.name
+							}), /* @__PURE__ */ jsxs("div", {
+								className: "font-mono text-xs text-text-secondary",
+								children: [runner.tokenPrefix, "…"]
+							})] }),
+							/* @__PURE__ */ jsx(TableCell, { children: /* @__PURE__ */ jsx(RunnerStatusPill, { status: runner.status }) }),
+							/* @__PURE__ */ jsx(TableCell, {
+								className: "text-sm text-text-secondary",
+								children: runner.hostname ? `${runner.hostname} · ${runner.os ?? "?"}/${runner.arch ?? "?"}` : "—"
+							}),
+							/* @__PURE__ */ jsxs(TableCell, {
+								className: "text-sm text-text-secondary",
+								children: [runner.driver ? /* @__PURE__ */ jsx(Badge, {
+									variant: "outline",
+									children: runner.driver
+								}) : "—", runner.version && /* @__PURE__ */ jsxs("span", {
+									className: "ml-2 text-xs",
+									children: ["v", runner.version]
+								})]
+							}),
+							/* @__PURE__ */ jsx(TableCell, {
+								className: "text-sm text-text-secondary",
+								children: /* @__PURE__ */ jsx(PrivateNetworkCell, { rules: runner.privateNetwork ?? [] })
+							}),
+							/* @__PURE__ */ jsx(TableCell, {
+								className: "text-sm text-text-secondary",
+								children: formatSeen(runner.lastSeenAt)
+							}),
+							/* @__PURE__ */ jsxs(TableCell, {
+								className: "text-right",
+								children: [/* @__PURE__ */ jsx(SdkPermissionButton, {
+									permission: FLUIDGRIDS_PERMISSIONS.SANDBOX_UPDATE,
+									deniedTooltip: tr("fluidgrids.runners.rotateDeniedTooltip", "You don't have permission to rotate runner tokens"),
+									children: /* @__PURE__ */ jsx(Button$1, {
+										"data-agent": "confirm",
+										variant: "ghost",
+										size: "sm",
+										title: tr("fluidgrids.runners.rotate", "Rotate token"),
+										onClick: () => handleRotate(runner),
+										disabled: busy,
+										"data-testid": "runner-rotate",
+										children: /* @__PURE__ */ jsx(Icon, {
+											icon: "lucide:key-round",
+											className: "h-4 w-4"
+										})
+									})
+								}), /* @__PURE__ */ jsx(SdkPermissionButton, {
+									permission: FLUIDGRIDS_PERMISSIONS.SANDBOX_DELETE,
+									deniedTooltip: tr("fluidgrids.runners.removeDeniedTooltip", "You don't have permission to remove runners"),
+									children: /* @__PURE__ */ jsx(Button$1, {
+										variant: "ghost",
+										size: "sm",
+										title: tr("fluidgrids.runners.remove", "Remove"),
+										onClick: () => setRemoving(runner),
+										disabled: busy,
+										"data-testid": "runner-remove",
+										children: /* @__PURE__ */ jsx(Icon, {
+											icon: "lucide:trash-2",
+											className: "h-4 w-4 text-destructive"
+										})
+									})
+								})]
+							})
+						]
+					}, runner.id)), !loading && runners.length === 0 && /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
+						colSpan: 7,
+						className: "py-10 text-center text-sm text-text-secondary",
+						children: tr("fluidgrids.runners.empty", "No runners yet. Add one to run nodes on your own machine.")
+					}) })] })] })
+				})
+			}),
+			/* @__PURE__ */ jsx(AddRunnerDialog, {
+				open: adding,
+				onOpenChange: setAdding,
+				runners,
+				onCreated: () => void refetch()
+			}),
+			/* @__PURE__ */ jsx(Dialog, {
+				open: rotated !== null,
+				onOpenChange: (open) => !open && setRotated(null),
+				children: /* @__PURE__ */ jsxs(DialogContent, {
+					className: "sm:max-w-2xl",
+					children: [
+						/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runners.rotatedTitle", "New token issued") }) }),
+						/* @__PURE__ */ jsx("p", {
+							className: "text-sm text-text-secondary",
+							children: tr("fluidgrids.runners.rotatedHint", "The old token no longer works and the runner was disconnected. Re-run the command below on that machine and paste the new token when it asks.")
+						}),
+						rotated && /* @__PURE__ */ jsx(InstallCommand, { issued: rotated }),
+						/* @__PURE__ */ jsx(DialogFooter, { children: /* @__PURE__ */ jsx(Button$1, {
+							variant: "outline",
+							onClick: () => setRotated(null),
+							children: tr("fluidgrids.runners.done", "Done")
+						}) })
+					]
+				})
+			}),
+			/* @__PURE__ */ jsx(Dialog, {
+				open: removing !== null,
+				onOpenChange: (open) => !open && setRemoving(null),
+				children: /* @__PURE__ */ jsxs(DialogContent, { children: [
+					/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.runners.removeTitle", "Remove this runner?") }) }),
+					/* @__PURE__ */ jsx("p", {
+						className: "text-sm text-text-secondary",
+						children: tr("fluidgrids.runners.removeHint", "It is disconnected and its token stops working. Nodes set to run on it will fail until you pick another runner or FluidGrids Cloud.")
+					}),
+					/* @__PURE__ */ jsxs(DialogFooter, { children: [/* @__PURE__ */ jsx(Button$1, {
+						variant: "outline",
+						onClick: () => setRemoving(null),
+						children: tr("fluidgrids.runners.cancel", "Cancel")
+					}), /* @__PURE__ */ jsx(Button$1, {
+						variant: "destructive",
+						onClick: handleRemove,
+						disabled: busy,
+						"data-testid": "runner-remove-confirm",
+						children: tr("fluidgrids.runners.remove", "Remove")
+					})] })
+				] })
+			})
+		]
+	});
+}
+
+export { RunnersPage_exports as n, RunnersPage as t };