@hansenexus/hud 0.2.0 → 0.4.0

package/dist/plugins/observe.js

@@ -0,0 +1,617 @@
+import { i as definePlugin } from "../plugins-DVy_vaYr.js";
+import { r as startVitals, t as VitalsPanel } from "../vitals-panel-Dvc5dnR-.js";
+import { useEffect, useLayoutEffect, useState, useSyncExternalStore, version } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/plugins/observe/capture-buffer.ts
+/**
+* Fixed-size ring buffer with a referentially-stable snapshot, shaped for
+* `useSyncExternalStore`: the snapshot array is replaced on every mutation
+* and reused between mutations.
+*/
+var CaptureBuffer = class {
+	entries = [];
+	snapshot = [];
+	listeners = /* @__PURE__ */ new Set();
+	nextId = 1;
+	maxEntries;
+	constructor(maxEntries = 500) {
+		this.maxEntries = maxEntries;
+	}
+	push(input) {
+		const entry = {
+			id: this.nextId++,
+			ts: Date.now(),
+			...input
+		};
+		this.entries.push(entry);
+		if (this.entries.length > this.maxEntries) this.entries.splice(0, this.entries.length - this.maxEntries);
+		this.emit();
+		return entry;
+	}
+	clear() {
+		if (this.entries.length === 0) return;
+		this.entries = [];
+		this.emit();
+	}
+	getSnapshot = () => this.snapshot;
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	emit() {
+		this.snapshot = [...this.entries];
+		for (const listener of this.listeners) listener();
+	}
+};
+/** Shared buffer the capture patches write into and the console tab reads from. */
+const captureBuffer = new CaptureBuffer(500);
+/**
+* What the pill counts as an error: `console.error`, uncaught errors and
+* rejections, and requests that failed outright or answered 5xx. A 4xx is the
+* app's business (a 404 probe, a 401 before login), so it stays a plain fetch.
+*/
+function isError(entry) {
+	if (entry.kind === "error") return true;
+	return entry.kind === "fetch" && entry.status !== void 0 && (entry.status === 0 || entry.status >= 500);
+}
+//#endregion
+//#region src/plugins/observe/capture.ts
+const MAX_TEXT = 300;
+let installs = 0;
+const restorers = [];
+const isHudRoute = (url) => url.includes("/api/hud/");
+function toText(args) {
+	return args.map((arg) => {
+		if (typeof arg === "string") return arg;
+		if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+		try {
+			return JSON.stringify(arg) ?? String(arg);
+		} catch {
+			return String(arg);
+		}
+	}).join(" ").slice(0, MAX_TEXT);
+}
+/**
+* Pushes on a microtask. React logs dev warnings with `console.error` while it
+* renders; a synchronous push would notify the console tab's store in the
+* middle of that render, React would warn about the update, and the warning
+* would land here again.
+*/
+function record(input) {
+	queueMicrotask(() => captureBuffer.push(input));
+}
+function patchConsole() {
+	for (const kind of [
+		"log",
+		"warn",
+		"error"
+	]) {
+		const original = console[kind];
+		console[kind] = (...args) => {
+			record({
+				kind,
+				text: toText(args)
+			});
+			original.apply(console, args);
+		};
+		restorers.push(() => {
+			console[kind] = original;
+		});
+	}
+}
+function listenErrors() {
+	const onError = (event) => {
+		record({
+			kind: "error",
+			text: toText([event.error instanceof Error ? event.error : event.message])
+		});
+	};
+	const onRejection = (event) => {
+		record({
+			kind: "error",
+			text: `Unhandled rejection: ${toText([event.reason])}`
+		});
+	};
+	window.addEventListener("error", onError);
+	window.addEventListener("unhandledrejection", onRejection);
+	restorers.push(() => {
+		window.removeEventListener("error", onError);
+		window.removeEventListener("unhandledrejection", onRejection);
+	});
+}
+function hasInternalHeader(input, init) {
+	try {
+		if (new Headers(init?.headers).has("x-hud-internal")) return true;
+		return input instanceof Request && input.headers.has("x-hud-internal");
+	} catch {
+		return false;
+	}
+}
+function patchFetch(ignore) {
+	const originalFetch = window.fetch;
+	const callOriginal = originalFetch.bind(window);
+	const patched = async (input, init) => {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		if (ignore(url) || hasInternalHeader(input, init)) return callOriginal(input, init);
+		const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+		const started = performance.now();
+		const elapsed = () => Math.round(performance.now() - started);
+		try {
+			const response = await callOriginal(input, init);
+			record({
+				kind: "fetch",
+				text: `${method} ${url}`.slice(0, MAX_TEXT),
+				status: response.status,
+				durationMs: elapsed()
+			});
+			return response;
+		} catch (error) {
+			record({
+				kind: "fetch",
+				text: `${method} ${url} — ${toText([error])}`.slice(0, MAX_TEXT),
+				status: 0,
+				durationMs: elapsed()
+			});
+			throw error;
+		}
+	};
+	window.fetch = Object.assign(patched, originalFetch);
+	restorers.push(() => {
+		window.fetch = originalFetch;
+	});
+}
+function observeLongTasks() {
+	if (typeof PerformanceObserver === "undefined") return;
+	try {
+		const observer = new PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) {
+				const durationMs = Math.round(entry.duration);
+				record({
+					kind: "longtask",
+					text: `long task ${durationMs} ms`,
+					durationMs
+				});
+			}
+		});
+		observer.observe({
+			type: "longtask",
+			buffered: true
+		});
+		restorers.push(() => observer.disconnect());
+	} catch {}
+}
+/**
+* Installs the patches on the first call and returns a release function; the
+* last release restores the originals. Reference counted so StrictMode's
+* mount-unmount-mount and two HUDs on one page neither double-patch nor
+* unpatch under each other. The first caller's options win.
+*/
+function installCapture({ ignore = isHudRoute } = {}) {
+	if (typeof window === "undefined") return () => {};
+	if (installs === 0) {
+		patchConsole();
+		listenErrors();
+		patchFetch(ignore);
+		observeLongTasks();
+	}
+	installs++;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		installs--;
+		if (installs === 0) while (restorers.length > 0) restorers.pop()?.();
+	};
+}
+//#endregion
+//#region src/plugins/observe/view.ts
+const FILTERS = [
+	"all",
+	"errors",
+	"warn",
+	"log",
+	"fetch",
+	"longtask"
+];
+function matches(entry, filter) {
+	if (filter === "all") return true;
+	if (filter === "errors") return isError(entry);
+	return entry.kind === filter;
+}
+let view = {
+	tab: "console",
+	filter: "all"
+};
+const listeners = /* @__PURE__ */ new Set();
+function setView(next) {
+	view = {
+		...view,
+		...next
+	};
+	for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+const getView = () => view;
+function useView() {
+	return useSyncExternalStore(subscribe, getView, getView);
+}
+function useCapture() {
+	return useSyncExternalStore(captureBuffer.subscribe, captureBuffer.getSnapshot, captureBuffer.getSnapshot);
+}
+//#endregion
+//#region src/plugins/observe/console-tab.tsx
+function statusLevel(status) {
+	if (status === 0 || status >= 500) return "error";
+	return status >= 400 ? "warn" : "ok";
+}
+/** Console, fetch and long-task capture, newest first. */
+function ConsoleTab() {
+	const entries = useCapture();
+	const { filter } = useView();
+	const rows = entries.filter((entry) => matches(entry, filter)).slice(-200).reverse();
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "obs-toolbar",
+		role: "toolbar",
+		"aria-label": "Filter",
+		children: [FILTERS.map((f) => /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: "obs-chip",
+			"aria-pressed": filter === f,
+			onClick: () => setView({ filter: f }),
+			children: [f, f !== "all" && /* @__PURE__ */ jsx("span", {
+				className: "obs-count",
+				children: entries.filter((e) => matches(e, f)).length
+			})]
+		}, f)), /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: "obs-chip obs-clear",
+			onClick: () => captureBuffer.clear(),
+			children: "clear"
+		})]
+	}), /* @__PURE__ */ jsx("div", {
+		className: "obs-log",
+		children: rows.length === 0 ? /* @__PURE__ */ jsx("p", {
+			className: "empty",
+			children: filter === "all" ? "Nothing captured yet. Console output, requests and long tasks land here." : `No ${filter} captured.`
+		}) : rows.map((entry) => /* @__PURE__ */ jsx(EntryRow, { entry }, entry.id))
+	})] });
+}
+function EntryRow({ entry }) {
+	const time = new Date(entry.ts).toLocaleTimeString(void 0, { hour12: false });
+	return /* @__PURE__ */ jsxs("div", {
+		className: "obs-row",
+		"data-kind": entry.kind,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "obs-time",
+				children: time
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "obs-kind",
+				"data-kind": entry.kind,
+				children: entry.kind
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "obs-text",
+				title: entry.text,
+				children: entry.text
+			}),
+			entry.status !== void 0 && /* @__PURE__ */ jsx("span", {
+				className: "obs-status",
+				"data-level": statusLevel(entry.status),
+				children: entry.status || "ERR"
+			}),
+			entry.durationMs !== void 0 && /* @__PURE__ */ jsxs("span", {
+				className: "obs-ms",
+				children: [entry.durationMs, " ms"]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/plugins/observe/info-tab.tsx
+/** App, build, browser and user snapshot: what runs here right now. */
+function InfoTab({ app, env, useUser }) {
+	const user = useUser();
+	const viewport = useViewportLabel();
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsxs(Section, {
+			title: "App",
+			children: [
+				/* @__PURE__ */ jsx(Row, {
+					label: "App",
+					value: app
+				}),
+				/* @__PURE__ */ jsx(Row, {
+					label: "Origin",
+					value: window.location.origin,
+					copy: true
+				}),
+				/* @__PURE__ */ jsx(Row, {
+					label: "Path",
+					value: window.location.pathname + window.location.search,
+					copy: true
+				})
+			]
+		}),
+		/* @__PURE__ */ jsxs(Section, {
+			title: "Build",
+			children: [/* @__PURE__ */ jsx(Row, {
+				label: "React",
+				value: version
+			}), Object.entries(env).map(([label, value]) => /* @__PURE__ */ jsx(Row, {
+				label,
+				value: value ?? "not set",
+				copy: value !== void 0
+			}, label))]
+		}),
+		user && /* @__PURE__ */ jsxs(Section, {
+			title: "User",
+			children: [
+				user.name !== void 0 && /* @__PURE__ */ jsx(Row, {
+					label: "Name",
+					value: user.name
+				}),
+				user.email !== void 0 && /* @__PURE__ */ jsx(Row, {
+					label: "Email",
+					value: user.email,
+					copy: true
+				}),
+				user.id !== void 0 && /* @__PURE__ */ jsx(Row, {
+					label: "ID",
+					value: user.id,
+					copy: true
+				}),
+				user.role !== void 0 && /* @__PURE__ */ jsx(Row, {
+					label: "Role",
+					value: user.role
+				}),
+				Object.entries(user.extra ?? {}).map(([label, value]) => /* @__PURE__ */ jsx(Row, {
+					label,
+					value
+				}, label))
+			]
+		}),
+		/* @__PURE__ */ jsxs(Section, {
+			title: "Browser",
+			children: [
+				/* @__PURE__ */ jsx(Row, {
+					label: "Viewport",
+					value: viewport
+				}),
+				/* @__PURE__ */ jsx(Row, {
+					label: "Language",
+					value: navigator.language
+				}),
+				/* @__PURE__ */ jsx(Row, {
+					label: "User agent",
+					value: navigator.userAgent,
+					copy: true
+				})
+			]
+		})
+	] });
+}
+function viewportLabel() {
+	const dark = window.matchMedia?.("(prefers-color-scheme: dark)").matches ?? false;
+	return `${window.innerWidth}×${window.innerHeight} @${window.devicePixelRatio}x · ${dark ? "dark" : "light"}`;
+}
+function useViewportLabel() {
+	const [label, setLabel] = useState(viewportLabel);
+	useEffect(() => {
+		const update = () => setLabel(viewportLabel());
+		window.addEventListener("resize", update);
+		return () => window.removeEventListener("resize", update);
+	}, []);
+	return label;
+}
+function Section({ title, children }) {
+	return /* @__PURE__ */ jsxs("section", {
+		className: "obs-section",
+		"aria-label": title,
+		children: [/* @__PURE__ */ jsx("h4", {
+			className: "obs-heading",
+			children: title
+		}), /* @__PURE__ */ jsx("dl", {
+			className: "obs-info",
+			children
+		})]
+	});
+}
+function Row({ label, value, copy = false }) {
+	const [copied, setCopied] = useState(false);
+	useEffect(() => {
+		if (!copied) return;
+		const timer = setTimeout(() => setCopied(false), 1200);
+		return () => clearTimeout(timer);
+	}, [copied]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("dt", {
+		title: label,
+		children: label
+	}), /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsxs("div", {
+		className: "obs-value",
+		children: [/* @__PURE__ */ jsx("span", {
+			title: value,
+			children: value
+		}), copy && /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: "obs-copy",
+			"aria-label": `Copy ${label}`,
+			onClick: () => {
+				navigator.clipboard?.writeText(value).then(() => setCopied(true), () => {});
+			},
+			children: copied ? "copied" : "copy"
+		})]
+	}) })] });
+}
+//#endregion
+//#region src/plugins/observe/styles.ts
+/**
+* The observe panel's styles. The panel renders them in its own `<style>`,
+* which still sits inside the HUD's shadow root, so they ship only with this
+* plugin and build on the shell's `--hud-*` tokens.
+*/
+const OBSERVE_CSS = `
+/* Fixed width, so switching tabs does not resize the floating panel. */
+.obs { display: flex; flex-direction: column; gap: 8px; width: 396px; max-width: 100%; }
+
+.obs-tabs { display: flex; gap: 2px; border-bottom: 1px solid var(--hud-border); }
+.hud .obs-tab {
+  padding: 3px 10px 5px;
+  margin-bottom: -1px;
+  border-bottom: 2px solid transparent;
+  color: var(--hud-fg-muted);
+}
+.hud .obs-tab[aria-selected="true"] { border-bottom-color: var(--hud-accent); color: var(--hud-fg); font-weight: 600; }
+
+.obs-toolbar { display: flex; flex-wrap: wrap; align-items: center; gap: 2px; }
+.hud .obs-chip {
+  padding: 1px 7px;
+  border-radius: 999px;
+  font-family: var(--hud-mono);
+  font-size: 11px;
+  color: var(--hud-fg-muted);
+}
+.hud .obs-chip:hover { background: var(--hud-bg-subtle); }
+.hud .obs-chip[aria-pressed="true"] { background: var(--hud-bg-subtle); color: var(--hud-fg); }
+.obs-chip .obs-count { margin-left: 4px; opacity: 0.6; }
+.hud .obs-clear { margin-left: auto; }
+
+.obs-log {
+  max-height: 320px;
+  overflow: auto;
+  border: 1px solid var(--hud-border);
+  border-radius: 4px;
+  font-family: var(--hud-mono);
+  font-size: 11px;
+}
+.obs-row { display: flex; align-items: baseline; gap: 8px; padding: 2px 6px; }
+.obs-row:hover { background: var(--hud-bg-subtle); }
+.obs-row + .obs-row { border-top: 1px solid var(--hud-border); }
+.obs-time, .obs-ms { flex-shrink: 0; color: var(--hud-fg-muted); }
+.obs-kind { flex-shrink: 0; width: 56px; text-transform: uppercase; color: var(--hud-fg-muted); }
+.obs-kind[data-kind="warn"] { color: var(--hud-warn); }
+.obs-kind[data-kind="error"] { color: var(--hud-poor); }
+.obs-kind[data-kind="fetch"] { color: var(--hud-accent); }
+.obs-text { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.obs-status { flex-shrink: 0; color: var(--hud-good); }
+.obs-status[data-level="warn"] { color: var(--hud-warn); }
+.obs-status[data-level="error"] { color: var(--hud-poor); }
+.obs-log .empty { margin: 0; padding: 6px; font-family: var(--hud-font); }
+
+.obs-section + .obs-section { margin-top: 10px; }
+.obs-heading {
+  margin: 0 0 4px;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--hud-fg-muted);
+}
+.obs-info {
+  display: grid;
+  grid-template-columns: 88px minmax(0, 1fr);
+  gap: 2px 12px;
+  margin: 0;
+}
+.obs-info dt { color: var(--hud-fg-muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.obs-info dd { margin: 0; min-width: 0; font-family: var(--hud-mono); }
+.obs-value { display: flex; align-items: center; gap: 6px; }
+.obs-value span { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.hud .obs-copy { flex-shrink: 0; padding: 0 4px; border-radius: 4px; font-size: 10px; color: var(--hud-fg-muted); }
+.hud .obs-copy:hover { background: var(--hud-bg-subtle); color: var(--hud-fg); }
+`;
+//#endregion
+//#region src/plugins/observe/index.tsx
+const TABS = [
+	{
+		id: "console",
+		label: "Console"
+	},
+	{
+		id: "info",
+		label: "Info"
+	},
+	{
+		id: "vitals",
+		label: "Vitals"
+	}
+];
+const NO_ENV = {};
+const noUser = () => void 0;
+function useErrorCount() {
+	return useCapture().filter(isError).length;
+}
+/**
+* Console and network capture, an app/build/browser/user snapshot and the
+* page's Web Vitals. The pill counts errors; opening the panel while there are
+* any lands on the console filtered to them.
+*/
+function observe({ env = NO_ENV, useUser = noUser, ignore } = {}) {
+	function ObservePill() {
+		useEffect(() => installCapture(ignore ? { ignore } : {}), []);
+		useEffect(() => startVitals(), []);
+		const errors = useErrorCount();
+		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+			className: "dot",
+			"data-rating": errors > 0 ? "poor" : "good"
+		}), errors === 1 ? "1 error" : `${errors} errors`] });
+	}
+	function ObservePanel({ ctx }) {
+		const { tab } = useView();
+		useLayoutEffect(() => {
+			if (captureBuffer.getSnapshot().some(isError)) setView({
+				tab: "console",
+				filter: "errors"
+			});
+		}, []);
+		return /* @__PURE__ */ jsxs("div", {
+			className: "obs",
+			children: [
+				/* @__PURE__ */ jsx("style", { children: OBSERVE_CSS }),
+				/* @__PURE__ */ jsx("div", {
+					className: "obs-tabs",
+					role: "tablist",
+					"aria-label": "Observe",
+					children: TABS.map(({ id, label }) => /* @__PURE__ */ jsx("button", {
+						type: "button",
+						role: "tab",
+						className: "obs-tab",
+						"aria-selected": tab === id,
+						onClick: () => setView({ tab: id }),
+						children: label
+					}, id))
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					role: "tabpanel",
+					"aria-label": TABS.find((t) => t.id === tab)?.label,
+					children: [
+						tab === "console" && /* @__PURE__ */ jsx(ConsoleTab, {}),
+						tab === "info" && /* @__PURE__ */ jsx(InfoTab, {
+							app: ctx.app,
+							env,
+							useUser
+						}),
+						tab === "vitals" && /* @__PURE__ */ jsx(VitalsPanel, {})
+					]
+				})
+			]
+		});
+	}
+	return definePlugin({
+		id: "observe",
+		title: "Observe",
+		pill: ObservePill,
+		panel: ObservePanel,
+		commands: [{
+			id: "clear",
+			title: "Clear console capture",
+			run: () => captureBuffer.clear()
+		}]
+	});
+}
+//#endregion
+export { observe };

package/dist/plugins/ops/server.d.ts

@@ -0,0 +1,82 @@
+import { d as HudRoutes } from "../../plugins-CQ_0w1ot.js";
+import { a as CiSnapshot, c as TelemetryRange, i as CiRun, l as TelemetryResponse, n as CiProvider, o as CiState, r as CiResponse, s as TelemetryProvider, t as CiDeployment, u as TelemetrySnapshot } from "../../types-f3jlNxzw.js";
+//#region src/plugins/ops/errors.d.ts
+/**
+ * A provider failure whose message is safe to send to the client (it names
+ * the upstream and its status, never a URL with credentials or a token).
+ * The routes answer 502 with it; any other error becomes a generic 502.
+ */
+export declare class OpsProviderError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/plugins/ops/github-actions.d.ts
+interface GithubActionsOptions {
+  /** `owner/name`. */
+  repo: string;
+  /**
+   * Branch whose runs the pill shows. Default: the first of `HUD_GIT_BRANCH`,
+   * `VERCEL_GIT_COMMIT_REF`, `GITHUB_HEAD_REF`, `GITHUB_REF_NAME`, then the
+   * branch checked out where the server runs (`.git/HEAD`). With no branch
+   * the panel lists the repo's latest runs and the pill shows no state.
+   */
+  branch?: string | (() => string | null | Promise<string | null>);
+  /** Env var holding the token, read on each request. Default `GITHUB_TOKEN`. */
+  tokenEnv?: string;
+  /** Runs listed in the panel. Default 10. */
+  limit?: number;
+  /** Seconds a GitHub answer is reused, to stay inside the rate limit. Default 15. */
+  cacheSeconds?: number;
+  /** API root, for GitHub Enterprise Server. Default `https://api.github.com`. */
+  apiUrl?: string;
+}
+/**
+ * GitHub Actions as the `ops` plugin's CI provider. Server only: the token is
+ * read from env on each request and only ever sent to GitHub.
+ *
+ * ```ts
+ * ops({ ci: githubActions({ repo: "hansenexus/hud" }) })
+ * ```
+ */
+export declare function githubActions(options: GithubActionsOptions): CiProvider;
+//#endregion
+//#region src/plugins/ops/signoz.d.ts
+interface SignozOptions {
+  /** OpenTelemetry `service.name` of the app. */
+  service: string;
+  /** Env var holding the SigNoz query URL, read on each request. Default `SIGNOZ_QUERY_URL`. */
+  urlEnv?: string;
+  /** Env var holding an API key, sent as `SIGNOZ-API-KEY` when set. Default `SIGNOZ_API_KEY`. */
+  apiKeyEnv?: string;
+}
+/**
+ * SigNoz as the `ops` plugin's telemetry provider: error rate, p95 latency and
+ * request rate of one service over its PromQL `query_range` API. Server only:
+ * the URL and API key come from env on each request.
+ *
+ * ```ts
+ * ops({ telemetry: signoz({ service: "hansenexus" }) })
+ * ```
+ */
+export declare function signoz(options: SignozOptions): TelemetryProvider;
+//#endregion
+//#region src/plugins/ops/server.d.ts
+export interface OpsServerOptions {
+  /** CI provider behind `GET /ops/ci`, such as `githubActions({ repo })`. */
+  ci?: CiProvider;
+  /** Telemetry provider behind `GET /ops/telemetry`, such as `signoz({ service })`. */
+  telemetry?: TelemetryProvider;
+}
+/**
+ * Server half of the `ops` plugin. Pass it to `createHudHandler`; each
+ * provider adds its route, so an app without telemetry serves no
+ * `/telemetry`. Tokens and keys stay in the providers: responses carry
+ * run data, numbers and the name of a missing env var, never a secret.
+ */
+export declare function ops({ ci, telemetry }?: OpsServerOptions): {
+  readonly id: "ops";
+  readonly capability: "cicd.read";
+  readonly routes: HudRoutes;
+};
+//#endregion
+export type { CiDeployment, CiProvider, CiResponse, CiRun, CiSnapshot, CiState, GithubActionsOptions, SignozOptions, TelemetryProvider, TelemetryRange, TelemetryResponse, TelemetrySnapshot };