@burdenoff/fluidgrids-fe-sdk 2026.1111.13 → 2026.1111.15

package/dist/fluidgridsEvents-CNdcrUNN.js

@@ -0,0 +1,310 @@
+"use client";
+// src/billing/quota.ts
+/**
+* Plan-quota refusals for the FluidGrids SDK.
+*
+* wspace-workflow-svc meters two quotas with `@usage`, and the gateway refuses
+* a call past either one with `429 QUOTA_EXHAUSTED`:
+*
+* - `fluidgrids.runs.monthly` — every mutation that starts a run:
+*   `triggerWorkflow`, `runFromNode`, `replayWorkflowRun`, `retryWorkflowRuns`
+*   and `listenForWebhookTestEvent`.
+* - `fluidgrids.workflows.count` — the mutations that create a workflow
+*   (save, duplicate, template import). Those keep their local
+*   `QuotaExhaustedDialog`.
+* - `fluidgrids.nodes.count` — node additions are counted by workflow save;
+*   the same save dialog handles its refusal.
+*
+* A run refusal opens the shell's shared upgrade prompt — see
+* `openRunQuotaUpgradePrompt` in `./upgradePrompt`. This module is the pure
+* detection half, so it imports nothing from `@burdenoff/fe-libs`.
+*
+* ★★ Why this does not just call fe-libs `isQuotaExhaustedError`. That helper
+* reads the Apollo 3 shapes (`graphQLErrors`, `networkError.result.errors`, a
+* code in the message). Under Apollo 4 — what every host runs — the refusal
+* never takes those shapes:
+*
+* - the gateway answers `429`, and Apollo 4's HTTP link turns any non-2xx
+*   `application/json` response into a `ServerError` whose GraphQL body is
+*   only in `bodyText` (message: "Response not successful: Received status
+*   code 429");
+* - a 2xx GraphQL error arrives as `CombinedGraphQLErrors`, whose list is
+*   `.errors`, not `.graphQLErrors`;
+* - `throwIfResultError` wraps either one in a plain `Error`, keeping the
+*   original as `cause`.
+*
+* None of those match, so the refusal read as an ordinary failure. This walker
+* reads all of them, and the Apollo 3 shapes too.
+*/
+/** The monthly run allowance every run-starting mutation is metered against. */
+const RUNS_QUOTA_NAME = "fluidgrids.runs.monthly";
+/** The workflow-count allowance save / duplicate / template import consume. */
+const WORKFLOWS_QUOTA_NAME = "fluidgrids.workflows.count";
+/**
+* Where an upgrade CTA sends the user: the plan picker, not the billing
+* overview. Matches the shared `UpgradePromptModal` default and the shell nav.
+*/
+const BILLING_PLANS_PATH = "/billing/plans";
+const QUOTA_EXHAUSTED_CODE = "QUOTA_EXHAUSTED";
+const QUOTA_NOT_PROVISIONED_CODE = "QUOTA_NOT_PROVISIONED";
+function asRecord$1(value) {
+	return typeof value === "object" && value !== null ? value : null;
+}
+/** The `extensions` of each entry of an `errors`-like list. */
+function extensionsOfList(list) {
+	if (!Array.isArray(list)) return [];
+	const found = [];
+	for (const entry of list) {
+		const extensions = asRecord$1(asRecord$1(entry)?.extensions);
+		if (extensions) found.push(extensions);
+	}
+	return found;
+}
+/** The GraphQL `errors[].extensions` inside a raw response body, if it is JSON. */
+function extensionsOfBody(bodyText) {
+	if (typeof bodyText !== "string" || !bodyText.includes("errors")) return [];
+	try {
+		return extensionsOfList(asRecord$1(JSON.parse(bodyText))?.errors);
+	} catch {
+		return [];
+	}
+}
+/** Bounds the `cause` walk; real chains are one or two links long. */
+const MAX_CAUSE_DEPTH = 5;
+/**
+* Every `extensions` object reachable on a thrown value, across the Apollo 3
+* and Apollo 4 shapes and the `cause` chain `throwIfResultError` adds.
+*/
+function collectExtensions(error) {
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth += 1) {
+		const host = asRecord$1(current);
+		if (!host || seen.has(host)) break;
+		seen.add(host);
+		const direct = asRecord$1(host.extensions);
+		if (direct) found.push(direct);
+		found.push(...extensionsOfList(host.errors));
+		found.push(...extensionsOfList(host.graphQLErrors));
+		const networkError = asRecord$1(host.networkError);
+		found.push(...extensionsOfList(asRecord$1(networkError?.result)?.errors));
+		found.push(...extensionsOfBody(networkError?.bodyText));
+		found.push(...extensionsOfList(asRecord$1(host.result)?.errors));
+		found.push(...extensionsOfBody(host.bodyText));
+		current = host.cause;
+	}
+	return found;
+}
+/** Every GraphQL `extensions.code` carried by `error` or its causes. */
+function errorCodesOf(error) {
+	return collectExtensions(error).map((ext) => ext.code).filter((code) => typeof code === "string");
+}
+function stringField(extensions, key) {
+	const value = extensions[key];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+/**
+* The refusal kind one GraphQL `extensions` object reports, or null.
+*
+* The gateway sets both `code` and `quotaBlock` on a quota refusal
+* (`sendQuotaExhausted` in wspace-public-gateway); either is enough here, so
+* a refusal relayed with only one of them (a proxy, an older gateway build)
+* still reads as one.
+*/
+function refusalKindOf(extensions) {
+	if (extensions.code === "QUOTA_NOT_PROVISIONED" || extensions.quotaBlock === "not-provisioned") return "not-provisioned";
+	if (extensions.code === "QUOTA_EXHAUSTED" || extensions.quotaBlock === "exhausted") return "exhausted";
+	return null;
+}
+/**
+* The quota refusal carried by `error`, or null when it is not one.
+*
+* Keyed on `extensions.code` (or the gateway's `extensions.quotaBlock`), never
+* on the HTTP status or the message: both refusals are 429s, and only those
+* fields tell "used up" from "never granted". `not-provisioned` wins when both
+* appear.
+*/
+function findQuotaRefusal(error) {
+	const all = collectExtensions(error);
+	const notProvisioned = all.find((ext) => refusalKindOf(ext) === "not-provisioned");
+	if (notProvisioned) return {
+		kind: "not-provisioned",
+		quotaName: stringField(notProvisioned, "quotaName"),
+		limitLeft: null
+	};
+	const exhausted = all.find((ext) => refusalKindOf(ext) === "exhausted");
+	if (exhausted) {
+		const limitLeft = exhausted.limitLeft;
+		return {
+			kind: "exhausted",
+			quotaName: stringField(exhausted, "quotaName"),
+			limitLeft: typeof limitLeft === "number" ? limitLeft : null
+		};
+	}
+	return null;
+}
+/** True when `error` is an exhausted (not merely unprovisioned) plan quota. */
+function isQuotaExhaustedFailure(error) {
+	return findQuotaRefusal(error)?.kind === "exhausted";
+}
+
+// src/analytics/fluidgridsEvents.ts
+/** `component` stamped on every event so devtools/OTel can tell the emitter. */
+const FLUIDGRIDS_ANALYTICS_COMPONENT = "fluidgrids-fe-sdk";
+/** Upper bound for a slug-like dimension; anything longer is not a slug. */
+const MAX_DIMENSION_LENGTH = 64;
+const SLUG_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_./:-]*$/;
+/**
+* Keep a dimension only when it is a short slug (`integration/slack`,
+* `trigger_webhook`, `marketing`). Anything else — spaces, free text, a very
+* long value — is dropped rather than risk sending user data.
+*/
+function toDimension(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (!trimmed || trimmed.length > MAX_DIMENSION_LENGTH) return void 0;
+	return SLUG_PATTERN.test(trimmed) ? trimmed : void 0;
+}
+/** Non-empty string id, or undefined. */
+function idOrUndefined(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/** A finite, non-negative integer count, or undefined. */
+function countOrUndefined(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
+}
+function emit(bus, name, payload) {
+	if (!bus) return;
+	const clean = Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0));
+	try {
+		bus.emit(name, clean, { component: FLUIDGRIDS_ANALYTICS_COMPONENT });
+	} catch (error) {
+		console.warn(`[fluidgrids analytics] failed to emit ${name}`, error);
+	}
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+/**
+* The executable node list of a workflow definition, wherever it sits: the
+* flow store's `{ nodes }`, a saved `definitionJson` (`{ data: { nodes } }`) or
+* a raw list.
+*/
+function nodesOf(definition) {
+	if (Array.isArray(definition)) return definition;
+	const record = asRecord(definition);
+	if (!record) return [];
+	if (Array.isArray(record.nodes)) return record.nodes;
+	const data = asRecord(record.data);
+	if (data && Array.isArray(data.nodes)) return data.nodes;
+	return [];
+}
+function isTriggerNode(node) {
+	if ((typeof node.type === "string" ? node.type.toLowerCase() : "").includes("trigger")) return true;
+	const data = asRecord(node.data);
+	return data?.isTrigger === true || data?.category === "trigger";
+}
+/** Node-type slug of the workflow's trigger node, when it has one. */
+function triggerTypeOf(definition) {
+	const trigger = nodesOf(definition).find(isTriggerNode);
+	return trigger ? toDimension(trigger.type) : void 0;
+}
+/** Number of executable nodes on the canvas. */
+function nodeCountOf(definition) {
+	const nodes = nodesOf(definition);
+	return nodes.length > 0 ? nodes.length : void 0;
+}
+/** `fluidgrids.workflow.created` — a new workflow exists in the workspace. */
+function emitWorkflowCreated(bus, fact) {
+	emit(bus, "fluidgrids.workflow.created", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		workflowId: idOrUndefined(fact.workflowId),
+		source: fact.source,
+		triggerType: triggerTypeOf(fact.definition),
+		nodeCount: nodeCountOf(fact.definition)
+	});
+}
+/** `fluidgrids.workflow.published` — a version was activated. */
+function emitWorkflowPublished(bus, fact) {
+	emit(bus, "fluidgrids.workflow.published", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		workflowId: idOrUndefined(fact.workflowId),
+		triggerType: triggerTypeOf(fact.definition),
+		nodeCount: nodeCountOf(fact.definition)
+	});
+}
+/** `fluidgrids.workflow.run_started` — the backend accepted a run. */
+function emitRunStarted(bus, fact) {
+	emit(bus, "fluidgrids.workflow.run_started", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		workflowId: idOrUndefined(fact.workflowId),
+		executionId: idOrUndefined(fact.executionId),
+		trigger: fact.trigger
+	});
+}
+/**
+* `fluidgrids.workflow.run_failed` — a run this user started ended FAILED.
+* `errorCode` is the run's machine error classification (`TIMEOUT`,
+* `VALIDATION`, …), never its message.
+*/
+function emitRunFailed(bus, fact) {
+	emit(bus, "fluidgrids.workflow.run_failed", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		workflowId: idOrUndefined(fact.workflowId),
+		executionId: idOrUndefined(fact.executionId),
+		trigger: fact.trigger,
+		errorCode: toDimension(fact.errorCode),
+		durationMs: countOrUndefined(fact.durationMs)
+	});
+}
+/** `fluidgrids.template.used` — a store template became a workflow. */
+function emitTemplateUsed(bus, fact) {
+	emit(bus, "fluidgrids.template.used", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		templateId: idOrUndefined(fact.templateId),
+		category: toDimension(fact.category)
+	});
+}
+/** `fluidgrids.node.installed` — a store node was installed. */
+function emitNodeInstalled(bus, fact) {
+	emit(bus, "fluidgrids.node.installed", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		nodeType: toDimension(fact.nodeType),
+		source: fact.source
+	});
+}
+/** `fluidgrids.quota.workflow_limit_hit` — a create was refused at the limit. */
+function emitWorkflowLimitHit(bus, fact) {
+	emit(bus, "fluidgrids.quota.workflow_limit_hit", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		quotaKey: WORKFLOWS_QUOTA_NAME,
+		surface: fact.surface
+	});
+}
+/** `fluidgrids.quota.run_limit_hit` — a run was refused at the monthly limit. */
+function emitRunLimitHit(bus, fact) {
+	emit(bus, "fluidgrids.quota.run_limit_hit", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		quotaKey: toDimension(fact.quotaKey) ?? "fluidgrids.runs.monthly",
+		surface: fact.surface
+	});
+}
+/** `fluidgrids.billing.upgrade_clicked` — a FluidGrids upgrade CTA was clicked. */
+function emitUpgradeClicked(bus, fact) {
+	emit(bus, "fluidgrids.billing.upgrade_clicked", {
+		workspaceId: idOrUndefined(fact.workspaceId),
+		surface: fact.surface,
+		quotaKey: toDimension(fact.quotaKey)
+	});
+}
+/**
+* Map a run's backend mode/trigger to the analytics trigger dimension. The
+* builder's debug paths are always `TEST`; anything else a person started by
+* hand is `manual`.
+*/
+function runTriggerFromMode(mode) {
+	return typeof mode === "string" && mode.toUpperCase() === "TEST" ? "test" : "manual";
+}
+
+export { errorCodesOf as _, emitTemplateUsed as a, emitWorkflowLimitHit as c, runTriggerFromMode as d, BILLING_PLANS_PATH as f, collectExtensions as g, WORKFLOWS_QUOTA_NAME as h, emitRunStarted as i, emitWorkflowPublished as l, RUNS_QUOTA_NAME as m, emitRunFailed as n, emitUpgradeClicked as o, QUOTA_EXHAUSTED_CODE as p, emitRunLimitHit as r, emitWorkflowCreated as s, emitNodeInstalled as t, nodesOf as u, findQuotaRefusal as v, isQuotaExhaustedFailure as y };

package/dist/history.js

@@ -1,4 +1,4 @@
 "use client";
-import { t as HistoryPage } from "./HistoryPage-DnVGN_72.js";
+import { t as HistoryPage } from "./HistoryPage-CA42pU85.js";
 
 export { HistoryPage };

package/dist/index-CHeY7_A1.d.ts

@@ -0,0 +1,105 @@
+
+import { FC } from "react";
+import { AnyDefinedAgentTool } from "@burdenoff/fe-libs/shared/agent-tools";
+declare const AGENT_OPERATIONS: {
+  readonly AgentFindWorkflows: "\n  query AgentFindWorkflows($input: ListWorkflowDefinitionsInput!) {\n    workflowDefinitions(input: $input) {\n      total\n      hasMore\n      items { id name workflowKey version status updatedAt workspaceId deletedAt description }\n    }\n  }\n";
+  readonly AgentGetWorkflow: "\n  query AgentGetWorkflow($workflowKey: String!, $version: String) {\n    workflowDefinition(workflowKey: $workflowKey, version: $version) {\n      id name workflowKey version status updatedAt description definitionJson totalVersions workspaceId deletedAt\n    }\n  }\n";
+  readonly AgentListRuns: "\n  query AgentListRuns($input: ListWorkflowRunsInput!) {\n    workflowRuns(input: $input) {\n      total\n      hasMore\n      items { id workflowKey version status mode startedAt completedAt duration errorMessage workflow { name } }\n    }\n  }\n";
+  readonly AgentGetRun: "\n  query AgentGetRun($id: ID!) {\n    workflowRun(id: $id) {\n      id workflowKey version status mode startedAt completedAt duration errorMessage errorType\n      totalNodes completedNodes failedNodes\n      workflow { name }\n      nodeStates { nodeId nodeType status error }\n    }\n  }\n";
+  readonly AgentActivateWorkflow: "\n  mutation AgentActivateWorkflow($id: ID!) {\n    activateWorkflowDefinition(id: $id) { workflowKey version status }\n  }\n";
+  readonly AgentDeactivateWorkflow: "\n  mutation AgentDeactivateWorkflow($id: ID!) {\n    deactivateWorkflowDefinition(id: $id) { workflowKey version status }\n  }\n";
+  readonly AgentTriggerWorkflow: "\n  mutation AgentTriggerWorkflow($input: TriggerWorkflowInput!) {\n    triggerWorkflow(input: $input) { runId status workflowKey version }\n  }\n";
+  readonly AgentCancelRun: "\n  mutation AgentCancelRun($id: ID!) {\n    cancelWorkflowRun(id: $id) { id status }\n  }\n";
+};
+type AgentOperationName = keyof typeof AGENT_OPERATIONS;
+interface FluidGridsAgentToolDeps {
+  request: <T>(operation: {
+    operationName: AgentOperationName;
+    query: string;
+    variables: Record<string, unknown>;
+    signal: AbortSignal;
+  }) => Promise<T>;
+  getWorkspaceId: () => string | null;
+  navigate: (path: string) => void;
+  listFilters?: () => Record<string, unknown> | undefined;
+}
+interface TriggerNode {
+  id: string;
+  label: string;
+  type: string;
+}
+declare function triggerNodesOf(definition: unknown): TriggerNode[];
+declare function pickTriggerNode(triggers: readonly TriggerNode[], requested: string | undefined): TriggerNode;
+declare function createFluidGridsAgentTools(deps: FluidGridsAgentToolDeps): AnyDefinedAgentTool[];
+interface AgentCalloutOverlayProps {
+  rightInset?: number;
+}
+declare const AgentCalloutOverlay: FC<AgentCalloutOverlayProps>;
+interface UiMarkToolOptions {
+  root?: () => ParentNode | null;
+  waitMs?: number;
+}
+declare function createUiMarkTools(options?: UiMarkToolOptions): AnyDefinedAgentTool[];
+type CanvasNoteKind = "fix" | "info";
+interface CalloutTarget {
+  role: string;
+  name: string;
+  nth: number;
+}
+interface AgentCallout {
+  id: string;
+  label: string;
+  target: CalloutTarget;
+  route: string;
+  element: WeakRef<Element> | null;
+}
+interface CanvasNote {
+  id: string;
+  number: number;
+  workflowKey: string;
+  nodeId: string;
+  nodeLabel: string;
+  paramKey: string | null;
+  kind: CanvasNoteKind;
+  message: string;
+  resolved: boolean;
+}
+interface NewCanvasNote {
+  workflowKey: string;
+  nodeId: string;
+  nodeLabel: string;
+  paramKey?: string | null;
+  kind: CanvasNoteKind;
+  message: string;
+}
+interface AgentMarksState {
+  callouts: AgentCallout[];
+  notes: CanvasNote[];
+  nextNumber: Record<string, number>;
+  openNoteId: string | null;
+  flash: {
+    nodeId: string;
+    token: number;
+  } | null;
+  actions: {
+    addCallout: (callout: {
+      label: string;
+      target: CalloutTarget;
+      element: Element | null;
+      route: string;
+    }) => AgentCallout;
+    rebindCallout: (id: string, element: Element) => void;
+    removeCallout: (id: string) => void;
+    clearCallouts: () => number;
+    dropCalloutsOffRoute: (route: string) => number;
+    addNote: (note: NewCanvasNote) => CanvasNote | null;
+    setResolved: (id: string, resolved: boolean) => void;
+    removeNote: (id: string) => void;
+    clearNotes: (workflowKey?: string) => number;
+    openNote: (id: string | null) => void;
+    flashNode: (nodeId: string) => void;
+  };
+}
+declare const useAgentMarksStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AgentMarksState>>;
+declare function resetAgentMarks(): void;
+export { createUiMarkTools as a, FluidGridsAgentToolDeps as c, triggerNodesOf as d, UiMarkToolOptions as i, createFluidGridsAgentTools as l, resetAgentMarks as n, AgentCalloutOverlay as o, useAgentMarksStore as r, AgentCalloutOverlayProps as s, CanvasNote as t, pickTriggerNode as u };