@flanksource/clicky-ui 0.3.21 → 0.3.23

package/dist/data.js

@@ -35,6 +35,8 @@ import { LogViewer } from "./data/LogViewer.js";
 import { LogsTable } from "./data/LogsTable.js";
 import { normalizeLogsTableRows } from "./data/logs-normalize.js";
 import { MatrixTable } from "./data/MatrixTable.js";
+import { Callout } from "./data/Callout.js";
+import { CALLOUT_TONES, CALLOUT_VARIANTS, CALLOUT_VARIANT_LABELS, assertCalloutValue, calloutVariantStyles } from "./data/callout-tones.js";
 import { Markdown } from "./data/Markdown.js";
 import { MarkdownEditor } from "./data/MarkdownEditor.js";
 import { MARKDOWN_EDITOR_PREVIEW_FORMATS, buildMarkdownPreviewUrl, clickyFormatForMarkdownPreview } from "./data/MarkdownEditor.model.js";
@@ -64,6 +66,7 @@ import { Version } from "./data/Version.js";
 import { getVersionInfo } from "./data/version-info.js";
 import { Tree } from "./data/Tree.js";
 import { ObjectGraph } from "./data/ObjectGraph.js";
+import { countObjectGraphNodes, pruneNullNodes } from "./data/object-graph-nodes.js";
 import { ExecutionTree } from "./data/ExecutionTree.js";
 import { TreeNode } from "./data/TreeNode.js";
 import { TreeGroupHeader } from "./data/TreeGroupHeader.js";
@@ -82,7 +85,9 @@ import { DiagnosticsDetailPanel } from "./data/diagnostics/DiagnosticsDetailPane
 import { countProcesses, findProcessByPID, processLabel, processStateColor, processStateIcon } from "./data/diagnostics/utils.js";
 import { countGoroutinesByState, countStackByState, detectDumpFormat, parseGoroutineDump, parseStackDump } from "./data/diagnostics/stacktrace.js";
 import { countThreadsByState, parseJvmThreadDump } from "./data/diagnostics/jvm-stacktrace.js";
-import { JvmStackFrameRow, JvmStackTrace } from "./data/diagnostics/JvmStackTrace.js";
+import { JvmStackTrace } from "./data/diagnostics/JvmStackTrace.js";
+import { StackFrameRow } from "./data/diagnostics/StackFrameRow.js";
+import { RUNTIME_PREFIXES, frameLocation, isRuntimeFrame, shortFrameName } from "./data/diagnostics/frame-heuristics.js";
 import { FrameSourceWindow } from "./data/diagnostics/FrameSourceWindow.js";
 import { frameHasSource } from "./data/diagnostics/FrameSourceWindow.utils.js";
 import { StackTrace } from "./data/diagnostics/RenderedStackTrace.js";
@@ -96,10 +101,13 @@ import { CacheDetailPanel } from "./data/cache-browser/CacheDetailPanel.js";
 import { CacheNodeRow, CacheTree } from "./data/cache-browser/CacheTree.js";
 import { CacheStatsOverview } from "./data/cache-browser/CacheStatsOverview.js";
 import { CacheValue } from "./data/cache-browser/CacheValue.js";
+import { ClickyExportDialog } from "./data/clicky-export/ClickyExportDialog.js";
 import { FixtureEditor } from "./data/FixtureEditor/FixtureEditor.js";
 import { GitChangedFilesSummary, GitCommitList, GitDiffPanel, GitFileList } from "./data/git/GitChangeList.js";
+import { QUERY_INFO_CONTENT_TYPE, buildQueryInfoUrl, fetchQueryInfo } from "./data/query-info/queryInfo.js";
 import { QueryBrowser } from "./data/query-browser/QueryBrowser.js";
 import { QueryBrowserExecutionError } from "./data/query-browser/QueryBrowser.types.js";
+import { QueryInfoDialog } from "./data/query-info/QueryInfoDialog.js";
 import { STATUS_LABELS, aggregateStatusCounts, collapseSingleChildChains, collectFrameworks, filterTests, formatCount, formatTestDuration, hasFailed, hasPending, humanizeName, statusIconFor, statusToneFor, sum, sumNonTaskTests, testStatus, totalDuration } from "./data/test-runner/status.js";
 import { TestAttempts, TestFailureDetail, TestOutput } from "./data/test-runner/TestFailureDetail.js";
 import { TestDetailPanel } from "./data/test-runner/TestDetailPanel.js";
@@ -121,6 +129,7 @@ import { UiArrowLeft, UiArrowLeftFilled } from "./icons/components/UiArrowLeft.j
 import { UiArrowRight, UiArrowRightFilled } from "./icons/components/UiArrowRight.js";
 import { UiArrowUp, UiArrowUpFilled } from "./icons/components/UiArrowUp.js";
 import { UiArrowUpRight } from "./icons/components/UiArrowUpRight.js";
+import { UiArrowsCounterClockwise, UiArrowsCounterClockwiseFilled } from "./icons/components/UiArrowsCounterClockwise.js";
 import { UiAsterisk, UiAsteriskFilled } from "./icons/components/UiAsterisk.js";
 import { UiAsyncFn } from "./icons/components/UiAsyncFn.js";
 import { UiAt, UiAtFilled } from "./icons/components/UiAt.js";
@@ -162,6 +171,7 @@ import { UiCircleFilled, UiCircleFilledFilled } from "./icons/components/UiCircl
 import { UiCircleOutline, UiCircleOutlineFilled } from "./icons/components/UiCircleOutline.js";
 import { UiCircleX, UiCircleXFilled } from "./icons/components/UiCircleX.js";
 import { UiClass } from "./icons/components/UiClass.js";
+import { UiClipboardText, UiClipboardTextFilled } from "./icons/components/UiClipboardText.js";
 import { UiClock, UiClockFilled } from "./icons/components/UiClock.js";
 import { UiClose, UiCloseFilled } from "./icons/components/UiClose.js";
 import { UiCloud, UiCloudFilled } from "./icons/components/UiCloud.js";
@@ -247,6 +257,7 @@ import { UiHistory, UiHistoryFilled } from "./icons/components/UiHistory.js";
 import { UiHome, UiHomeFilled } from "./icons/components/UiHome.js";
 import { UiHourglass, UiHourglassFilled } from "./icons/components/UiHourglass.js";
 import { UiHubot, UiHubotFilled } from "./icons/components/UiHubot.js";
+import { UiIdentificationCard, UiIdentificationCardFilled } from "./icons/components/UiIdentificationCard.js";
 import { UiImage, UiImageFilled } from "./icons/components/UiImage.js";
 import { UiImport } from "./icons/components/UiImport.js";
 import { UiInbox, UiInboxFilled } from "./icons/components/UiInbox.js";
@@ -281,6 +292,7 @@ import { UiListTree, UiListTreeFilled } from "./icons/components/UiListTree.js";
 import { UiLoader, UiLoaderFilled } from "./icons/components/UiLoader.js";
 import { UiLocation, UiLocationFilled } from "./icons/components/UiLocation.js";
 import { UiLock, UiLockFilled } from "./icons/components/UiLock.js";
+import { UiLockKey, UiLockKeyFilled } from "./icons/components/UiLockKey.js";
 import { UiLockOpen, UiLockOpenFilled } from "./icons/components/UiLockOpen.js";
 import { UiLogoAnthropic } from "./icons/components/UiLogoAnthropic.js";
 import { UiLogoClaude } from "./icons/components/UiLogoClaude.js";
@@ -386,6 +398,7 @@ import { UiSquare, UiSquareFilled } from "./icons/components/UiSquare.js";
 import { UiStack, UiStackFilled } from "./icons/components/UiStack.js";
 import { UiStackFrameDot } from "./icons/components/UiStackFrameDot.js";
 import { UiStar, UiStarFilled } from "./icons/components/UiStar.js";
+import { UiSteps, UiStepsFilled } from "./icons/components/UiSteps.js";
 import { UiStop } from "./icons/components/UiStop.js";
 import { UiStrategy, UiStrategyFilled } from "./icons/components/UiStrategy.js";
 import { UiString } from "./icons/components/UiString.js";
@@ -415,6 +428,8 @@ import { UiUpload, UiUploadFilled } from "./icons/components/UiUpload.js";
 import { UiUser, UiUserCheck, UiUserCheckFilled, UiUserFilled, UiUserMinus, UiUserMinusFilled, UiUserPlus, UiUserPlusFilled } from "./icons/components/UiUser.js";
 import { UiUserCircle, UiUserCircleCheck, UiUserCircleCheckFilled, UiUserCircleFilled, UiUserCircleMinus, UiUserCircleMinusFilled, UiUserCirclePlus, UiUserCirclePlusFilled } from "./icons/components/UiUserCircle.js";
 import { UiUserCog } from "./icons/components/UiUserCog.js";
+import { UiUserGear, UiUserGearFilled } from "./icons/components/UiUserGear.js";
+import { UiUsersFour, UiUsersFourFilled } from "./icons/components/UiUsersFour.js";
 import { UiUsersThree, UiUsersThreeCheck, UiUsersThreeCheckFilled, UiUsersThreeCross, UiUsersThreeCrossFilled, UiUsersThreeFilled, UiUsersThreeMinus, UiUsersThreeMinusFilled, UiUsersThreePlus, UiUsersThreePlusFilled } from "./icons/components/UiUsersThree.js";
 import { UiVariable } from "./icons/components/UiVariable.js";
 import { UiVideo, UiVideoFilled } from "./icons/components/UiVideo.js";
@@ -436,11 +451,16 @@ import { cycleFilterState, decodeFilterState, emptyTestFilters, encodeFilterStat
 import { formatGitCommitDateHeader } from "./data/git/git-dates.js";
 import { frameworkIcon } from "./data/test-runner/frameworkIcon.js";
 import { isLeaf } from "./data/cache-browser/types.js";
+import { useClickyExport } from "./data/clicky-export/useClickyExport.js";
+import { useQueryInfo } from "./data/query-info/useQueryInfo.js";
 export {
   AnsiHtml,
   Avatar,
   AvatarBadge,
   Badge,
+  CALLOUT_TONES,
+  CALLOUT_VARIANTS,
+  CALLOUT_VARIANT_LABELS,
   CacheAdapterRegistry,
   CacheBrowser,
   CacheDetailPanel,
@@ -448,7 +468,9 @@ export {
   CacheStatsOverview,
   CacheTree,
   CacheValue,
+  Callout,
   CellFilterActions,
+  ClickyExportDialog,
   CodeBlock,
   CodeDiff,
   CopyBadge,
@@ -473,7 +495,6 @@ export {
   HarPanel,
   Icon,
   JsonView,
-  JvmStackFrameRow,
   JvmStackTrace,
   KeyValueList,
   LabelIcon,
@@ -493,8 +514,11 @@ export {
   PromptBanner,
   PromptDialog,
   Properties,
+  QUERY_INFO_CONTENT_TYPE,
   QueryBrowser,
   QueryBrowserExecutionError,
+  QueryInfoDialog,
+  RUNTIME_PREFIXES,
   RadialGauge,
   STATUS_LABELS,
   STATUS_TOKEN_GROUPS,
@@ -505,6 +529,7 @@ export {
   ServerTimingBadge,
   SignedDeltaBar,
   SortableHeader,
+  StackFrameRow,
   StackTrace,
   StackedStatusBar,
   StatStrip,
@@ -553,6 +578,8 @@ export {
   UiArrowUp,
   UiArrowUpFilled,
   UiArrowUpRight,
+  UiArrowsCounterClockwise,
+  UiArrowsCounterClockwiseFilled,
   UiAsterisk,
   UiAsteriskFilled,
   UiAsyncFn,
@@ -631,6 +658,8 @@ export {
   UiCircleX,
   UiCircleXFilled,
   UiClass,
+  UiClipboardText,
+  UiClipboardTextFilled,
   UiClock,
   UiClockFilled,
   UiClose,
@@ -792,6 +821,8 @@ export {
   UiHourglassFilled,
   UiHubot,
   UiHubotFilled,
+  UiIdentificationCard,
+  UiIdentificationCardFilled,
   UiImage,
   UiImageFilled,
   UiImport,
@@ -851,6 +882,8 @@ export {
   UiLocationFilled,
   UiLock,
   UiLockFilled,
+  UiLockKey,
+  UiLockKeyFilled,
   UiLockOpen,
   UiLockOpenFilled,
   UiLogoAnthropic,
@@ -1035,6 +1068,8 @@ export {
   UiStackFrameDot,
   UiStar,
   UiStarFilled,
+  UiSteps,
+  UiStepsFilled,
   UiStop,
   UiStrategy,
   UiStrategyFilled,
@@ -1090,10 +1125,14 @@ export {
   UiUserCirclePlusFilled,
   UiUserCog,
   UiUserFilled,
+  UiUserGear,
+  UiUserGearFilled,
   UiUserMinus,
   UiUserMinusFilled,
   UiUserPlus,
   UiUserPlusFilled,
+  UiUsersFour,
+  UiUsersFourFilled,
   UiUsersThree,
   UiUsersThreeCheck,
   UiUsersThreeCheckFilled,
@@ -1130,14 +1169,17 @@ export {
   answerPrompt,
   applyFixtureFrontmatterRaw,
   applyFixtureFrontmatterState,
+  assertCalloutValue,
   assignAxes,
   badgeVariants,
   bucketTasks,
   buildMarkdownPreviewUrl,
+  buildQueryInfoUrl,
   buildSchemaTree,
   buildSchemaViewerTree,
   buildStepBranchTree,
   cacheQueryKeys,
+  calloutVariantStyles,
   changeIconAliases,
   chooseTimestampFormat,
   clickyFormatForMarkdownPreview,
@@ -1147,6 +1189,7 @@ export {
   compactStackPath,
   computeLineDiff,
   countGoroutinesByState,
+  countObjectGraphNodes,
   countProcesses,
   countStackByState,
   countThreadsByState,
@@ -1161,6 +1204,7 @@ export {
   detectDumpFormat,
   emptyTestFilters,
   encodeFilterState,
+  fetchQueryInfo,
   filterStateToRecord,
   filterTests,
   findNodeByRoutePath,
@@ -1179,6 +1223,7 @@ export {
   formatTestDuration,
   formatTimestamp,
   frameHasSource,
+  frameLocation,
   frameworkIcon,
   getChangeIcon,
   getVersionInfo,
@@ -1192,6 +1237,7 @@ export {
   isApplicationStackFrame,
   isGroupCollapsedByDefault,
   isLeaf,
+  isRuntimeFrame,
   isTerminalStatus,
   latestOf,
   logLevelColor,
@@ -1220,6 +1266,7 @@ export {
   processLabel,
   processStateColor,
   processStateIcon,
+  pruneNullNodes,
   recordToFilterState,
   resolveBreakdown,
   resolveFixtureFenceSchema,
@@ -1233,6 +1280,7 @@ export {
   serverTimingCounterSummary,
   serverTimingMetricLabel,
   setFallbackIconProvider,
+  shortFrameName,
   slugify,
   splitCommaValues,
   splitTagToken,
@@ -1251,7 +1299,9 @@ export {
   testStatus,
   totalDuration,
   updateFilterSelection,
+  useClickyExport,
   usePrompts,
+  useQueryInfo,
   useTagActions,
   useTagActionsValue,
   useTestRunner,

package/dist/data.js.map

@@ -1 +1 @@
-{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"data.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/hooks/use-log-tail.cjs

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "stopped", "interrupted"]);
+function isTerminalSessionState(state) {
+  return state !== void 0 && TERMINAL.has(state);
+}
+const emptyLogTailBuffer = { rows: [], lastSequence: null, dropped: 0 };
+function encodeTailParams(params) {
+  if (!params) return "";
+  const query = new URLSearchParams();
+  for (const key of Object.keys(params).sort()) {
+    const value = params[key];
+    if (value === void 0 || value === null) continue;
+    query.append(key, String(value));
+  }
+  const encoded = query.toString();
+  return encoded === "" ? "" : `&${encoded}`;
+}
+function appendTailEvent(buffer, event, maxRows) {
+  if (buffer.lastSequence !== null && event.sequence <= buffer.lastSequence) return buffer;
+  const incoming = event.rows ?? (event.row ? [event.row] : []);
+  if (incoming.length === 0) return { ...buffer, lastSequence: event.sequence };
+  const merged = buffer.rows.concat(incoming);
+  const overflow = Math.max(0, merged.length - Math.max(1, maxRows));
+  return {
+    rows: overflow > 0 ? merged.slice(overflow) : merged,
+    lastSequence: event.sequence,
+    dropped: buffer.dropped + overflow
+  };
+}
+const DEFAULT_BASE = "/api/v1";
+const DEFAULT_POLL_MS = 1e3;
+const DEFAULT_MAX_ROWS = 5e3;
+function hasEventSource() {
+  return typeof globalThis !== "undefined" && typeof globalThis.EventSource !== "undefined";
+}
+async function stopLogSession(basePath, id) {
+  const res = await fetch(`${basePath}/sessions/${encodeURIComponent(id)}`, {
+    method: "DELETE",
+    keepalive: true
+  });
+  if (!res.ok) {
+    throw new Error(await res.text() || `stopping session ${id} failed with HTTP ${res.status}`);
+  }
+}
+function useLogTail(options) {
+  const {
+    profile,
+    params,
+    basePath = DEFAULT_BASE,
+    following: wantFollow = false,
+    maxRows = DEFAULT_MAX_ROWS,
+    pollMs = DEFAULT_POLL_MS,
+    forcePoll = false
+  } = options;
+  const [buffer, setBuffer] = react.useState(emptyLogTailBuffer);
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const [session, setSession] = react.useState(null);
+  const maxRowsRef = react.useRef(maxRows);
+  maxRowsRef.current = maxRows;
+  const paramsQuery = encodeTailParams(params);
+  react.useEffect(() => {
+    if (!wantFollow) return;
+    setBuffer(emptyLogTailBuffer);
+    setError(null);
+    setSession(null);
+    setStatus("starting");
+    let cancelled = false;
+    let source;
+    let timer;
+    let liveSessionId = null;
+    let ended = false;
+    const apply = (event) => {
+      setBuffer((prev) => appendTailEvent(prev, event, maxRowsRef.current));
+      if (event.error) setError({ scope: "stream", message: event.error });
+    };
+    const readFrame = (label, e) => {
+      try {
+        return JSON.parse(e.data);
+      } catch (cause) {
+        setError({ scope: "stream", message: `unparseable ${label} frame: ${String(cause)}` });
+        return void 0;
+      }
+    };
+    const settle = (info) => {
+      setSession(info);
+      if (!isTerminalSessionState(info.state)) return;
+      ended = true;
+      setStatus(info.state);
+      if (info.state === "failed") {
+        setError({
+          scope: "session",
+          message: info.error || `session ${info.id} failed without reporting a reason`
+        });
+      }
+    };
+    const subscribe = (id) => {
+      const es = new EventSource(`${basePath}/sessions/${encodeURIComponent(id)}/events`);
+      source = es;
+      setStatus("streaming");
+      es.addEventListener("event", (e) => {
+        const frame = readFrame("event", e);
+        if (frame) apply(frame);
+      });
+      es.addEventListener("done", (e) => {
+        const info = readFrame("done", e);
+        if (info) settle(info);
+        es.close();
+      });
+      es.onerror = () => {
+        if (!ended) setStatus("connection lost — retrying");
+      };
+    };
+    const poll = (id) => {
+      let after = null;
+      const tick = async () => {
+        try {
+          const query = after === null ? "" : `?after=${after}`;
+          const res = await fetch(
+            `${basePath}/sessions/${encodeURIComponent(id)}/events${query}`,
+            { headers: { Accept: "application/json" } }
+          );
+          if (!res.ok) {
+            ended = true;
+            setStatus("failed");
+            setError({
+              scope: "session",
+              httpStatus: res.status,
+              message: `reading events for session ${id} failed with HTTP ${res.status}: ${(await res.text()).trim() || "no detail"}`
+            });
+            return;
+          }
+          for (const event of await res.json()) {
+            apply(event);
+            if (after === null || event.sequence > after) after = event.sequence;
+          }
+          setStatus("polling");
+        } catch {
+          setStatus("connection lost — retrying");
+        }
+        if (!cancelled) timer = setTimeout(tick, pollMs);
+      };
+      void tick();
+    };
+    const release = (id) => stopLogSession(basePath, id).catch((cause) => {
+      console.error(`[useLogTail] could not stop follow session ${id}`, cause);
+    });
+    const start = async () => {
+      let info;
+      try {
+        const res = await fetch(
+          `${basePath}/profile/${encodeURIComponent(profile)}/sessions?follow=true${paramsQuery}`,
+          { method: "POST", headers: { Accept: "application/json" } }
+        );
+        if (!res.ok) {
+          const detail = (await res.text()).trim() || "no detail";
+          setStatus("failed");
+          setError({
+            scope: "start",
+            httpStatus: res.status,
+            message: res.status === 409 ? `the server is already running as many follow sessions as it allows (HTTP 409): ${detail}` : `could not start a follow session for ${profile} (HTTP ${res.status}): ${detail}`
+          });
+          return;
+        }
+        info = await res.json();
+      } catch (cause) {
+        setStatus("failed");
+        setError({
+          scope: "start",
+          message: `could not reach ${basePath} to start a follow session for ${profile}: ${String(cause)}`
+        });
+        return;
+      }
+      if (cancelled) {
+        void release(info.id);
+        return;
+      }
+      liveSessionId = info.id;
+      setSession(info);
+      if (forcePoll || !hasEventSource()) poll(info.id);
+      else subscribe(info.id);
+    };
+    void start();
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+      source == null ? void 0 : source.close();
+      if (liveSessionId && !ended) void release(liveSessionId);
+    };
+  }, [profile, paramsQuery, basePath, wantFollow, pollMs, forcePoll]);
+  react.useEffect(() => {
+    if (!wantFollow) setStatus((prev) => TERMINAL.has(prev) ? prev : "idle");
+  }, [wantFollow]);
+  return {
+    rows: buffer.rows,
+    status,
+    error,
+    sessionId: (session == null ? void 0 : session.id) ?? null,
+    following: wantFollow && !TERMINAL.has(status),
+    droppedRows: buffer.dropped,
+    lastSequence: buffer.lastSequence,
+    session
+  };
+}
+exports.appendTailEvent = appendTailEvent;
+exports.emptyLogTailBuffer = emptyLogTailBuffer;
+exports.encodeTailParams = encodeTailParams;
+exports.isTerminalSessionState = isTerminalSessionState;
+exports.stopLogSession = stopLogSession;
+exports.useLogTail = useLogTail;
+//# sourceMappingURL=use-log-tail.cjs.map

package/dist/hooks/use-log-tail.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-log-tail.cjs","sources":["../../src/hooks/use-log-tail.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\n\n// use-log-tail is the clicky-ui client for a *follow* session: the server opens\n// a live source for a query profile and streams rows out of it until someone\n// closes it. It is shaped like use-task-run — SSE-first, polling only when\n// EventSource is missing — but the resource underneath is far less forgiving. A\n// follow session holds a websocket to Loki, or a log stream to a kubelet, for as\n// long as it exists, and the server caps how many may run at once\n// (ErrMaxSessions, surfaced as HTTP 409). A session that is left behind is\n// therefore not untidy, it is a slot the next reader cannot have, which is why\n// stopping is a DELETE the hook issues on every exit path including unmount.\n//\n// The second thing this stream does differently is replay. Each SSE frame\n// carries an `id:`, so a reconnecting EventSource sends Last-Event-ID and the\n// server resumes from that sequence — re-delivering frames the client may\n// already hold. Sequences are the server's, not a client index: they do not\n// start at 1 and they do not reset, so the accumulator dedupes against the\n// highest sequence it has applied rather than against a position in an array.\n\nexport type LogSessionState =\n  | \"starting\"\n  | \"running\"\n  | \"completed\"\n  | \"failed\"\n  | \"stopped\"\n  | \"interrupted\";\n\n/** SessionInfo as returned by POST /profile/{name}/sessions and the `done` frame. */\nexport interface LogSessionInfo {\n  id: string;\n  profile: string;\n  kind: string;\n  state: LogSessionState;\n  params?: Record<string, unknown>;\n  error?: string;\n  eventCount: number;\n  startedAt: string;\n  stoppedAt?: string;\n}\n\n/**\n * One `event:` frame. It carries either a single `row` or a batch under `rows`\n * — never both — plus an `error` when the source failed mid-stream without the\n * session itself ending.\n */\nexport interface LogTailEvent {\n  sessionId: string;\n  sequence: number;\n  time?: string;\n  row?: Record<string, unknown>;\n  rows?: Record<string, unknown>[];\n  error?: string;\n}\n\n/**\n * Where a failure came from, because the three are not interchangeable to a\n * reader: `start` means the session never existed (409 is the cap), `stream`\n * means the session is alive but something in it went wrong, and `session`\n * means the server ended it.\n */\nexport interface LogTailError {\n  scope: \"start\" | \"stream\" | \"session\";\n  message: string;\n  /** HTTP status when a request produced the failure. 409 is the session cap. */\n  httpStatus?: number;\n}\n\n/** Renderable transport/session state. The terminal values are the server's own. */\nexport type LogTailStatus =\n  | \"idle\"\n  | \"starting\"\n  | \"streaming\"\n  | \"polling\"\n  | \"connection lost — retrying\"\n  | \"completed\"\n  | \"failed\"\n  | \"stopped\"\n  | \"interrupted\";\n\nconst TERMINAL: ReadonlySet<string> = new Set([\"completed\", \"failed\", \"stopped\", \"interrupted\"]);\n\nexport function isTerminalSessionState(state: LogSessionState | undefined): boolean {\n  return state !== undefined && TERMINAL.has(state);\n}\n\nexport interface LogTailBuffer {\n  /** Rows in arrival order, oldest first — the order this surface tails in. */\n  rows: Record<string, unknown>[];\n  /** Highest sequence applied, or null before the first frame. Never assumed to start at 1. */\n  lastSequence: number | null;\n  /** Rows evicted by the cap. Kept so the UI can say so instead of quietly shortening history. */\n  dropped: number;\n}\n\nexport const emptyLogTailBuffer: LogTailBuffer = { rows: [], lastSequence: null, dropped: 0 };\n\n/**\n * Renders profile parameters as the tail of a session request's query string,\n * `\"\"` when there are none, and each entry already `&`-prefixed so it appends\n * to a query that always begins with `?follow=true`.\n *\n * Keys are sorted so two callers passing the same parameters in a different\n * order produce the same string — the effect that opens the session depends on\n * it, and an unstable spelling would tear down a live tail and start a new one\n * on a render that changed nothing.\n *\n * A null or undefined value is omitted rather than sent as the text \"null\": the\n * server reads every query key as a supplied parameter, so spelling an absent\n * one out states a filter the caller did not ask for.\n */\nexport function encodeTailParams(params: Record<string, unknown> | undefined): string {\n  if (!params) return \"\";\n  const query = new URLSearchParams();\n  for (const key of Object.keys(params).sort()) {\n    const value = params[key];\n    if (value === undefined || value === null) continue;\n    query.append(key, String(value));\n  }\n  const encoded = query.toString();\n  return encoded === \"\" ? \"\" : `&${encoded}`;\n}\n\n/**\n * Applies one frame to the buffer, dropping anything at or below the highest\n * sequence already seen. A watermark is enough — and cheaper than remembering\n * every id — because SSE is ordered within a connection and the only source of\n * duplicates is a reconnect, whose replay starts at Last-Event-ID and so can\n * only re-deliver frames the buffer has already passed.\n *\n * Returns the buffer unchanged when the frame adds nothing, so React can bail\n * out of the render.\n */\nexport function appendTailEvent(\n  buffer: LogTailBuffer,\n  event: LogTailEvent,\n  maxRows: number,\n): LogTailBuffer {\n  if (buffer.lastSequence !== null && event.sequence <= buffer.lastSequence) return buffer;\n  const incoming = event.rows ?? (event.row ? [event.row] : []);\n  if (incoming.length === 0) return { ...buffer, lastSequence: event.sequence };\n\n  const merged = buffer.rows.concat(incoming);\n  const overflow = Math.max(0, merged.length - Math.max(1, maxRows));\n  return {\n    rows: overflow > 0 ? merged.slice(overflow) : merged,\n    lastSequence: event.sequence,\n    dropped: buffer.dropped + overflow,\n  };\n}\n\nexport interface UseLogTailOptions {\n  /** Query profile to follow, e.g. \"k8s-pod-logs\". */\n  profile: string;\n  /** Profile parameters, sent as the session request's query string. */\n  params?: Record<string, unknown> | undefined;\n  /** Base path of the session API, e.g. \"/api/v1\". */\n  basePath?: string | undefined;\n  /** Start/stop is the caller's: flipping this to false DELETEs the session. */\n  following?: boolean | undefined;\n  /** Rows kept in memory; older ones are evicted and counted in `droppedRows`. */\n  maxRows?: number | undefined;\n  /** Poll interval (ms) for the fallback transport. */\n  pollMs?: number | undefined;\n  /** Force polling even when EventSource exists (mainly tests). */\n  forcePoll?: boolean | undefined;\n}\n\nexport interface UseLogTailResult {\n  /** Accumulated rows, oldest first. */\n  rows: Record<string, unknown>[];\n  status: LogTailStatus;\n  error: LogTailError | null;\n  sessionId: string | null;\n  /** True while the caller wants rows and the session has not reached a terminal state. */\n  following: boolean;\n  /** Rows the cap evicted; non-zero means the tail no longer holds the whole run. */\n  droppedRows: number;\n  /** Highest sequence applied — the resume point a reconnect would ask for. */\n  lastSequence: number | null;\n  /** Latest SessionInfo the server sent, for eventCount / startedAt / state. */\n  session: LogSessionInfo | null;\n}\n\nconst DEFAULT_BASE = \"/api/v1\";\nconst DEFAULT_POLL_MS = 1_000;\nconst DEFAULT_MAX_ROWS = 5_000;\n\nfunction hasEventSource(): boolean {\n  return typeof globalThis !== \"undefined\" && typeof globalThis.EventSource !== \"undefined\";\n}\n\n/** DELETE the session. Exported because a caller that owns the id (a saved tail,\n *  a beforeunload handler) has to be able to release it without the hook. */\nexport async function stopLogSession(basePath: string, id: string): Promise<void> {\n  const res = await fetch(`${basePath}/sessions/${encodeURIComponent(id)}`, {\n    method: \"DELETE\",\n    keepalive: true,\n  });\n  if (!res.ok) {\n    throw new Error((await res.text()) || `stopping session ${id} failed with HTTP ${res.status}`);\n  }\n}\n\nexport function useLogTail(options: UseLogTailOptions): UseLogTailResult {\n  const {\n    profile,\n    params,\n    basePath = DEFAULT_BASE,\n    following: wantFollow = false,\n    maxRows = DEFAULT_MAX_ROWS,\n    pollMs = DEFAULT_POLL_MS,\n    forcePoll = false,\n  } = options;\n\n  const [buffer, setBuffer] = useState<LogTailBuffer>(emptyLogTailBuffer);\n  const [status, setStatus] = useState<LogTailStatus>(\"idle\");\n  const [error, setError] = useState<LogTailError | null>(null);\n  const [session, setSession] = useState<LogSessionInfo | null>(null);\n\n  // The cap is read when a frame lands rather than closed over, so changing how\n  // much history to keep never tears down a live session to do it.\n  const maxRowsRef = useRef(maxRows);\n  maxRowsRef.current = maxRows;\n\n  // Profile parameters travel in the query string because that is where the\n  // session endpoint reads them from: it builds its params by walking\n  // r.URL.Query() and never looks at the body, so a posted body is a filter the\n  // server silently ignores — the tail would run the profile's defaults while\n  // the reader believed they were following what they had filtered to.\n  //\n  // Serialized here rather than in the effect so it is also the effect's\n  // dependency: two renders with equal parameters must not restart the session.\n  const paramsQuery = encodeTailParams(params);\n\n  useEffect(() => {\n    if (!wantFollow) return;\n\n    // Each start is a distinct server session replaying from its own first\n    // sequence, so the previous run's rows cannot be continued — carrying them\n    // over would interleave two unrelated sequence spaces in one list.\n    setBuffer(emptyLogTailBuffer);\n    setError(null);\n    setSession(null);\n    setStatus(\"starting\");\n\n    let cancelled = false;\n    let source: EventSource | undefined;\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let liveSessionId: string | null = null;\n    let ended = false;\n\n    const apply = (event: LogTailEvent) => {\n      setBuffer((prev) => appendTailEvent(prev, event, maxRowsRef.current));\n      // An event-level error does not end the session, so it is reported beside\n      // the rows rather than in place of them.\n      if (event.error) setError({ scope: \"stream\", message: event.error });\n    };\n\n    // Unlike the task stream this does not skip what it cannot parse: a tail\n    // that silently discards frames is indistinguishable from a quiet log\n    // source, which is the one thing a reader must never be left guessing at.\n    const readFrame = (label: string, e: MessageEvent): unknown => {\n      try {\n        return JSON.parse(e.data as string);\n      } catch (cause) {\n        setError({ scope: \"stream\", message: `unparseable ${label} frame: ${String(cause)}` });\n        return undefined;\n      }\n    };\n\n    const settle = (info: LogSessionInfo) => {\n      setSession(info);\n      if (!isTerminalSessionState(info.state)) return;\n      ended = true;\n      setStatus(info.state as LogTailStatus);\n      if (info.state === \"failed\") {\n        setError({\n          scope: \"session\",\n          message: info.error || `session ${info.id} failed without reporting a reason`,\n        });\n      }\n    };\n\n    const subscribe = (id: string) => {\n      const es = new EventSource(`${basePath}/sessions/${encodeURIComponent(id)}/events`);\n      source = es;\n      setStatus(\"streaming\");\n      es.addEventListener(\"event\", (e) => {\n        const frame = readFrame(\"event\", e as MessageEvent);\n        if (frame) apply(frame as LogTailEvent);\n      });\n      es.addEventListener(\"done\", (e) => {\n        const info = readFrame(\"done\", e as MessageEvent);\n        if (info) settle(info as LogSessionInfo);\n        es.close();\n      });\n      // A dropped connection is not a failure: EventSource reconnects with\n      // Last-Event-ID and the server replays. It is reported through `status`\n      // only, so a blip never leaves a sticky error the reader has to dismiss —\n      // and never after the session ended, where it would overwrite the reason\n      // it ended with a reconnect that is not going to happen.\n      es.onerror = () => {\n        if (!ended) setStatus(\"connection lost — retrying\");\n      };\n    };\n\n    // The polling transport asks for the same replay the SSE reconnect gets:\n    // `after` is Last-Event-ID by another name.\n    const poll = (id: string) => {\n      let after: number | null = null;\n      const tick = async () => {\n        try {\n          const query = after === null ? \"\" : `?after=${after}`;\n          const res = await fetch(\n            `${basePath}/sessions/${encodeURIComponent(id)}/events${query}`,\n            { headers: { Accept: \"application/json\" } },\n          );\n          if (!res.ok) {\n            // A refused request is the session answering that it is gone or\n            // broken; retrying it forever would render as an empty tail.\n            ended = true;\n            setStatus(\"failed\");\n            setError({\n              scope: \"session\",\n              httpStatus: res.status,\n              message: `reading events for session ${id} failed with HTTP ${res.status}: ${\n                (await res.text()).trim() || \"no detail\"\n              }`,\n            });\n            return;\n          }\n          for (const event of (await res.json()) as LogTailEvent[]) {\n            apply(event);\n            if (after === null || event.sequence > after) after = event.sequence;\n          }\n          setStatus(\"polling\");\n        } catch {\n          setStatus(\"connection lost — retrying\");\n        }\n        if (!cancelled) timer = setTimeout(tick, pollMs);\n      };\n      void tick();\n    };\n\n    // Releasing can run while the component is already gone, so a failure here\n    // cannot be raised into state — but it is the failure that costs everyone\n    // else a session slot, so it is never swallowed either.\n    const release = (id: string) =>\n      stopLogSession(basePath, id).catch((cause: unknown) => {\n        console.error(`[useLogTail] could not stop follow session ${id}`, cause);\n      });\n\n    const start = async () => {\n      let info: LogSessionInfo;\n      try {\n        const res = await fetch(\n          `${basePath}/profile/${encodeURIComponent(profile)}/sessions?follow=true${paramsQuery}`,\n          { method: \"POST\", headers: { Accept: \"application/json\" } },\n        );\n        if (!res.ok) {\n          const detail = (await res.text()).trim() || \"no detail\";\n          setStatus(\"failed\");\n          setError({\n            scope: \"start\",\n            httpStatus: res.status,\n            message:\n              res.status === 409\n                ? `the server is already running as many follow sessions as it allows (HTTP 409): ${detail}`\n                : `could not start a follow session for ${profile} (HTTP ${res.status}): ${detail}`,\n          });\n          return;\n        }\n        info = (await res.json()) as LogSessionInfo;\n      } catch (cause) {\n        setStatus(\"failed\");\n        setError({\n          scope: \"start\",\n          message: `could not reach ${basePath} to start a follow session for ${profile}: ${String(cause)}`,\n        });\n        return;\n      }\n\n      if (cancelled) {\n        // The caller stopped following while the POST was in flight. The session\n        // exists on the server regardless, so it still has to be released.\n        void release(info.id);\n        return;\n      }\n      liveSessionId = info.id;\n      setSession(info);\n      if (forcePoll || !hasEventSource()) poll(info.id);\n      else subscribe(info.id);\n    };\n\n    void start();\n    // A session left running is not untidy, it is a slot the next reader cannot\n    // have — so it is released on every exit path, unmount included.\n    return () => {\n      cancelled = true;\n      if (timer) clearTimeout(timer);\n      source?.close();\n      if (liveSessionId && !ended) void release(liveSessionId);\n    };\n  }, [profile, paramsQuery, basePath, wantFollow, pollMs, forcePoll]);\n\n  // Stopping returns the surface to idle, but a session that ended on its own\n  // keeps its terminal status so the reason it ended stays on screen.\n  useEffect(() => {\n    if (!wantFollow) setStatus((prev) => (TERMINAL.has(prev) ? prev : \"idle\"));\n  }, [wantFollow]);\n\n  return {\n    rows: buffer.rows,\n    status,\n    error,\n    sessionId: session?.id ?? null,\n    following: wantFollow && !TERMINAL.has(status),\n    droppedRows: buffer.dropped,\n    lastSequence: buffer.lastSequence,\n    session,\n  };\n}\n"],"names":["useState","useRef","useEffect"],"mappings":"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"}

package/dist/hooks/use-log-tail.d.ts

@@ -0,0 +1,112 @@
+export type LogSessionState = "starting" | "running" | "completed" | "failed" | "stopped" | "interrupted";
+/** SessionInfo as returned by POST /profile/{name}/sessions and the `done` frame. */
+export interface LogSessionInfo {
+    id: string;
+    profile: string;
+    kind: string;
+    state: LogSessionState;
+    params?: Record<string, unknown>;
+    error?: string;
+    eventCount: number;
+    startedAt: string;
+    stoppedAt?: string;
+}
+/**
+ * One `event:` frame. It carries either a single `row` or a batch under `rows`
+ * — never both — plus an `error` when the source failed mid-stream without the
+ * session itself ending.
+ */
+export interface LogTailEvent {
+    sessionId: string;
+    sequence: number;
+    time?: string;
+    row?: Record<string, unknown>;
+    rows?: Record<string, unknown>[];
+    error?: string;
+}
+/**
+ * Where a failure came from, because the three are not interchangeable to a
+ * reader: `start` means the session never existed (409 is the cap), `stream`
+ * means the session is alive but something in it went wrong, and `session`
+ * means the server ended it.
+ */
+export interface LogTailError {
+    scope: "start" | "stream" | "session";
+    message: string;
+    /** HTTP status when a request produced the failure. 409 is the session cap. */
+    httpStatus?: number;
+}
+/** Renderable transport/session state. The terminal values are the server's own. */
+export type LogTailStatus = "idle" | "starting" | "streaming" | "polling" | "connection lost — retrying" | "completed" | "failed" | "stopped" | "interrupted";
+export declare function isTerminalSessionState(state: LogSessionState | undefined): boolean;
+export interface LogTailBuffer {
+    /** Rows in arrival order, oldest first — the order this surface tails in. */
+    rows: Record<string, unknown>[];
+    /** Highest sequence applied, or null before the first frame. Never assumed to start at 1. */
+    lastSequence: number | null;
+    /** Rows evicted by the cap. Kept so the UI can say so instead of quietly shortening history. */
+    dropped: number;
+}
+export declare const emptyLogTailBuffer: LogTailBuffer;
+/**
+ * Renders profile parameters as the tail of a session request's query string,
+ * `""` when there are none, and each entry already `&`-prefixed so it appends
+ * to a query that always begins with `?follow=true`.
+ *
+ * Keys are sorted so two callers passing the same parameters in a different
+ * order produce the same string — the effect that opens the session depends on
+ * it, and an unstable spelling would tear down a live tail and start a new one
+ * on a render that changed nothing.
+ *
+ * A null or undefined value is omitted rather than sent as the text "null": the
+ * server reads every query key as a supplied parameter, so spelling an absent
+ * one out states a filter the caller did not ask for.
+ */
+export declare function encodeTailParams(params: Record<string, unknown> | undefined): string;
+/**
+ * Applies one frame to the buffer, dropping anything at or below the highest
+ * sequence already seen. A watermark is enough — and cheaper than remembering
+ * every id — because SSE is ordered within a connection and the only source of
+ * duplicates is a reconnect, whose replay starts at Last-Event-ID and so can
+ * only re-deliver frames the buffer has already passed.
+ *
+ * Returns the buffer unchanged when the frame adds nothing, so React can bail
+ * out of the render.
+ */
+export declare function appendTailEvent(buffer: LogTailBuffer, event: LogTailEvent, maxRows: number): LogTailBuffer;
+export interface UseLogTailOptions {
+    /** Query profile to follow, e.g. "k8s-pod-logs". */
+    profile: string;
+    /** Profile parameters, sent as the session request's query string. */
+    params?: Record<string, unknown> | undefined;
+    /** Base path of the session API, e.g. "/api/v1". */
+    basePath?: string | undefined;
+    /** Start/stop is the caller's: flipping this to false DELETEs the session. */
+    following?: boolean | undefined;
+    /** Rows kept in memory; older ones are evicted and counted in `droppedRows`. */
+    maxRows?: number | undefined;
+    /** Poll interval (ms) for the fallback transport. */
+    pollMs?: number | undefined;
+    /** Force polling even when EventSource exists (mainly tests). */
+    forcePoll?: boolean | undefined;
+}
+export interface UseLogTailResult {
+    /** Accumulated rows, oldest first. */
+    rows: Record<string, unknown>[];
+    status: LogTailStatus;
+    error: LogTailError | null;
+    sessionId: string | null;
+    /** True while the caller wants rows and the session has not reached a terminal state. */
+    following: boolean;
+    /** Rows the cap evicted; non-zero means the tail no longer holds the whole run. */
+    droppedRows: number;
+    /** Highest sequence applied — the resume point a reconnect would ask for. */
+    lastSequence: number | null;
+    /** Latest SessionInfo the server sent, for eventCount / startedAt / state. */
+    session: LogSessionInfo | null;
+}
+/** DELETE the session. Exported because a caller that owns the id (a saved tail,
+ *  a beforeunload handler) has to be able to release it without the hook. */
+export declare function stopLogSession(basePath: string, id: string): Promise<void>;
+export declare function useLogTail(options: UseLogTailOptions): UseLogTailResult;
+//# sourceMappingURL=use-log-tail.d.ts.map

package/dist/hooks/use-log-tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-log-tail.d.ts","sourceRoot":"","sources":["../../src/hooks/use-log-tail.ts"],"names":[],"mappings":"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"}