@plitzi/sdk-interactions 0.33.2 → 0.34.0

package/dist/sources/ActionsSource/ActionInteractions.mjs

@@ -0,0 +1,409 @@
+import e from "../../InteractionsContext.mjs";
+import { actionsCallbacks as t } from "./callbacks.mjs";
+import { use as n, useCallback as r, useMemo as i } from "react";
+import { pConsole as a } from "@plitzi/sdk-shared/devTools/utils/PlitziConsole";
+import { jsx as o, jsxs as s } from "react/jsx-runtime";
+import { recordActionProgress as c, recordActionRun as l, registerActionCanceller as u, releaseActionCanceller as d, updateActionRun as f, useCommonStore as p } from "@plitzi/sdk-shared/store";
+import { authFailureFromResponse as m, reportAuthFailure as h } from "@plitzi/sdk-shared/auth";
+import { toBuilderParams as g, toInteractionCallbacks as _ } from "@plitzi/sdk-shared/authoring/builder";
+//#region src/sources/ActionsSource/ActionInteractions.tsx
+var v = async (e, t) => {
+	let n = e.getReader(), r = new TextDecoder(), i = "";
+	for (;;) {
+		let { done: e, value: a } = await n.read();
+		if (e) return;
+		i += r.decode(a, { stream: !0 });
+		let o = i.split("\n\n");
+		i = o.pop() ?? "";
+		for (let e of o) {
+			let n = /event: (\w+)/.exec(e)?.[1];
+			if (!n) continue;
+			let r = e.split("\n").filter((e) => e.startsWith("data:")).map((e) => e.slice(5).trimStart()).join("\n");
+			try {
+				t({
+					event: n,
+					data: r ? JSON.parse(r) : {}
+				});
+			} catch {}
+		}
+	}
+}, y = (e) => {
+	if (!e) return {};
+	if (typeof e == "object") return e;
+	try {
+		let t = JSON.parse(e);
+		return typeof t == "object" && t ? t : {};
+	} catch {
+		return {};
+	}
+}, b = {
+	status: "failed",
+	reason: "failed",
+	runId: "",
+	output: {}
+}, x = (e, t) => e.signal.aborted ? {
+	status: "aborted",
+	error: "Cancelled"
+} : {
+	status: "failed",
+	error: t instanceof Error ? t.message : String(t)
+}, S = (e, t, n) => {
+	if (e !== 401) return;
+	let r = m(e, t);
+	r && h({
+		reason: r,
+		url: n
+	});
+}, C = ({ children: m }) => {
+	let { useInteractions: h, interactionsManager: C } = n(e), [w] = p("actions.endpoint"), [[T, E]] = p(["actions.catalog", "actions.available"]), D = r((e, t, n) => {
+		e && C.interactionTrigger(e, t, n);
+	}, [C]), O = r(async (e, t) => {
+		let { actionId: n, mode: r = "await", idempotencyKey: i } = e;
+		if (!w) return a.warning("actions", /* @__PURE__ */ s("span", { children: [
+			"Server action ",
+			/* @__PURE__ */ o("b", { children: n }),
+			" was skipped: this page is served without a Plitzi server"
+		] }), {
+			actionId: n,
+			status: "skipped"
+		}), {
+			status: "skipped",
+			runId: "",
+			output: {}
+		};
+		if (!n) return {
+			status: "skipped",
+			runId: "",
+			output: {}
+		};
+		let p = y(e.input), m = JSON.stringify({
+			actionId: n,
+			input: p,
+			...i ? { idempotencyKey: i } : {}
+		}), h = l({
+			actionId: n,
+			mode: r,
+			input: p
+		}), g = new AbortController(), _ = "";
+		u(h, () => {
+			g.abort(), f(h, {
+				status: "aborted",
+				endedAt: Date.now(),
+				cancellable: !1
+			}), _ && fetch(`${w}/run/${_}`, {
+				method: "DELETE",
+				credentials: "same-origin"
+			}).catch(() => void 0);
+		});
+		let C = (e) => {
+			d(h), f(h, {
+				endedAt: Date.now(),
+				cancellable: !1,
+				...e
+			});
+		};
+		if (r === "detached") return a.info("actions", /* @__PURE__ */ s("span", { children: [
+			"Server action ",
+			/* @__PURE__ */ o("b", { children: n }),
+			" sent"
+		] }), {
+			actionId: n,
+			mode: r,
+			status: "accepted"
+		}), fetch(w, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			credentials: "same-origin",
+			keepalive: !0,
+			signal: g.signal,
+			body: m
+		}).then(async (e) => {
+			let i = await e.json().catch(() => ({}));
+			if (!e.ok) {
+				S(e.status, i, w), C({
+					status: "failed",
+					...i.runId ? { runId: i.runId } : {},
+					...i.reason ? { reason: i.reason } : {},
+					...i.error ? { error: i.error } : {}
+				}), D(t?.hostElementId, "onFlowError", {
+					actionId: n,
+					runId: i.runId ?? "",
+					error: i.error ?? "",
+					reason: i.reason ?? "failed"
+				});
+				return;
+			}
+			C({
+				status: i.status === "completed" ? "completed" : "accepted",
+				...i.runId ? { runId: i.runId } : {},
+				...i.output ? { output: i.output } : {},
+				...i.trace ? { trace: i.trace } : {}
+			}), a.success("actions", /* @__PURE__ */ s("span", { children: [
+				"Server action ",
+				/* @__PURE__ */ o("b", { children: n }),
+				" finished"
+			] }), {
+				actionId: n,
+				mode: r,
+				runId: i.runId,
+				status: i.status,
+				output: i.output
+			}), D(t?.hostElementId, "onFlowEnd", {
+				actionId: n,
+				runId: i.runId ?? "",
+				status: i.status ?? "completed",
+				output: i.output ?? {}
+			});
+		}).catch((e) => {
+			C(x(g, e)), a.warning("actions", /* @__PURE__ */ s("span", { children: [
+				"Server action ",
+				/* @__PURE__ */ o("b", { children: n }),
+				" could not be sent"
+			] }), {
+				actionId: n,
+				mode: r,
+				error: e instanceof Error ? e.message : String(e)
+			}), D(t?.hostElementId, "onFlowError", {
+				actionId: n,
+				runId: "",
+				error: "",
+				reason: "failed"
+			});
+		}), {
+			accepted: !0,
+			status: "accepted",
+			runId: "",
+			output: {}
+		};
+		if (r === "stream") {
+			a.info("actions", /* @__PURE__ */ s("span", { children: [
+				"Server action ",
+				/* @__PURE__ */ o("b", { children: n }),
+				" streaming"
+			] }), {
+				actionId: n,
+				mode: r,
+				status: "streaming"
+			});
+			let e;
+			try {
+				e = await fetch(w, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Accept: "text/event-stream"
+					},
+					credentials: "same-origin",
+					signal: g.signal,
+					body: m
+				});
+			} catch (e) {
+				return C(x(g, e)), a.warning("actions", /* @__PURE__ */ s("span", { children: [
+					"Server action ",
+					/* @__PURE__ */ o("b", { children: n }),
+					" could not be reached"
+				] }), {
+					actionId: n,
+					mode: r,
+					error: e instanceof Error ? e.message : String(e)
+				}), D(t?.hostElementId, "onFlowError", {
+					actionId: n,
+					runId: "",
+					error: "",
+					reason: "failed"
+				}), b;
+			}
+			if (!e.ok || !e.body) {
+				let r = await e.json().catch(() => ({}));
+				return S(e.status, r, w), C({
+					status: "failed",
+					...r.runId ? { runId: r.runId } : {},
+					...r.reason ? { reason: r.reason } : {},
+					...r.error ? { error: r.error } : {}
+				}), D(t?.hostElementId, "onFlowError", {
+					actionId: n,
+					runId: r.runId ?? "",
+					error: r.error ?? "",
+					reason: r.reason ?? "failed"
+				}), {
+					status: "failed",
+					reason: r.reason ?? "failed",
+					runId: "",
+					output: {}
+				};
+			}
+			let i = e.headers.get("X-Plitzi-Run-Id") ?? "";
+			return _ = i, f(h, {
+				status: "streaming",
+				...i ? { runId: i } : {}
+			}), v(e.body, (e) => {
+				if (e.event === "data") {
+					c(h, e.data.chunk ?? e.data), D(t?.hostElementId, "onFlowProgress", {
+						actionId: n,
+						runId: i,
+						...e.data
+					});
+					return;
+				}
+				if (e.event === "error") {
+					C({
+						status: "failed",
+						...typeof e.data.reason == "string" ? { reason: e.data.reason } : {},
+						...typeof e.data.error == "string" ? { error: e.data.error } : {}
+					}), D(t?.hostElementId, "onFlowError", {
+						actionId: n,
+						runId: i,
+						...e.data
+					});
+					return;
+				}
+				e.event === "done" && (C({
+					status: e.data.status === "completed" ? "completed" : "failed",
+					...e.data.output ? { output: e.data.output } : {}
+				}), D(t?.hostElementId, "onFlowEnd", {
+					actionId: n,
+					runId: i,
+					...e.data
+				}));
+			}).catch((e) => {
+				if (g.signal.aborted) return;
+				let c = e instanceof Error ? e.message : String(e);
+				C({
+					status: "failed",
+					error: c
+				}), a.warning("actions", /* @__PURE__ */ s("span", { children: [
+					"Server action ",
+					/* @__PURE__ */ o("b", { children: n }),
+					" stopped mid-stream"
+				] }), {
+					actionId: n,
+					mode: r,
+					runId: i,
+					error: c
+				}), D(t?.hostElementId, "onFlowError", {
+					actionId: n,
+					runId: i,
+					error: c,
+					reason: "failed"
+				});
+			}), {
+				accepted: !0,
+				status: "streaming",
+				runId: i,
+				output: {}
+			};
+		}
+		let T;
+		try {
+			T = await fetch(w, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				credentials: "same-origin",
+				signal: g.signal,
+				body: m
+			});
+		} catch (e) {
+			return C(x(g, e)), a.warning("interactions", /* @__PURE__ */ s("span", { children: [
+				"Server action ",
+				/* @__PURE__ */ o("b", { children: n }),
+				" could not be reached"
+			] }), {
+				actionId: n,
+				error: e instanceof Error ? e.message : String(e)
+			}), D(t?.hostElementId, "onFlowError", {
+				actionId: n,
+				runId: "",
+				error: "",
+				reason: "failed"
+			}), b;
+		}
+		let E = await T.json().catch(() => ({}));
+		return T.ok ? (C({
+			status: E.status === "completed" ? "completed" : "failed",
+			...E.runId ? { runId: E.runId } : {},
+			...E.output ? { output: E.output } : {},
+			...E.trace ? { trace: E.trace } : {}
+		}), {
+			status: E.status ?? "completed",
+			runId: E.runId ?? "",
+			output: E.output ?? {}
+		}) : (S(T.status, E, w), C({
+			status: "failed",
+			...E.runId ? { runId: E.runId } : {},
+			...E.reason ? { reason: E.reason } : {},
+			...E.error ? { error: E.error } : {}
+		}), a.warning("actions", /* @__PURE__ */ s("span", { children: [
+			"Server action ",
+			/* @__PURE__ */ o("b", { children: n }),
+			" was refused"
+		] }), {
+			actionId: n,
+			mode: r,
+			runId: E.runId,
+			reason: E.reason,
+			error: E.error,
+			status: String(T.status)
+		}), {
+			status: "failed",
+			reason: E.reason ?? "failed",
+			runId: E.runId ?? "",
+			output: {}
+		});
+	}, [w, D]), k = r(async (e) => {
+		if (!w || !e.runId) return { cancelled: !1 };
+		try {
+			let t = (await fetch(`${w}/run/${e.runId}`, {
+				method: "DELETE",
+				credentials: "same-origin"
+			})).status === 204;
+			return a.info("actions", /* @__PURE__ */ s("span", { children: [
+				"Server action run ",
+				/* @__PURE__ */ o("b", { children: e.runId }),
+				" ",
+				t ? "cancelled" : "was not cancelled"
+			] }), {
+				actionId: "",
+				mode: "cancel",
+				runId: e.runId,
+				status: t ? "aborted" : "failed"
+			}), { cancelled: t };
+		} catch {
+			return { cancelled: !1 };
+		}
+	}, [w]), A = i(() => (T ?? []).map((e) => ({
+		label: `${e.name} (${e.identifier})`,
+		value: e.identifier
+	})), [T]);
+	return h({
+		id: "actions",
+		callbacks: i(() => _(t, {
+			cancelServerAction: k,
+			runServerAction: O
+		}, { runServerAction: { params: (e) => {
+			let n = g(t.runServerAction.params), r = (T ?? []).find((t) => t.identifier === e.actionId), i = Object.entries(r?.input ?? {});
+			return {
+				...n,
+				actionId: {
+					...n.actionId,
+					type: () => A.length > 0 ? "select" : "text",
+					canBind: !0,
+					label: E === !1 ? "Action — this space has no server to run it" : "Action",
+					options: A
+				},
+				input: {
+					...n.input,
+					canBind: !0,
+					label: i.length > 0 ? `Input — ${i.map(([e, t]) => `${e}${t.required ? "*" : ""}: ${t.type}`).join(", ")}` : "Input"
+				}
+			};
+		} } }), [
+			O,
+			k,
+			A,
+			T,
+			E
+		])
+	}), m;
+};
+//#endregion
+export { C as default };

package/dist/sources/ActionsSource/callbacks.d.ts

@@ -0,0 +1,12 @@
+import { BuiltinGlobalCallback } from '@plitzi/sdk-shared/authoring/builder';
+/**
+ * Running a server action from a flow, and cancelling one.
+ *
+ * The editor enriches both: it knows which actions the space publishes, so `actionId` becomes a picker and `input`
+ * announces the contract the chosen action declares. Neither fact is about the action-running callback itself,
+ * which is all this declares.
+ *
+ * `mode` is the param a flow is usually got wrong on: only `await` puts the result in the flow scope, so a step
+ * that reads `{{ <step>.output.* }}` after a detached run reads nothing at all.
+ */
+export declare const actionsCallbacks: Record<string, BuiltinGlobalCallback>;

package/dist/sources/ActionsSource/callbacks.mjs

@@ -0,0 +1,63 @@
+//#region src/sources/ActionsSource/callbacks.ts
+var e = {
+	runServerAction: {
+		source: "actions",
+		title: "Run Server Action",
+		strictParams: !0,
+		params: {
+			actionId: {
+				type: "text",
+				description: "Identifier of the server action to run, as the space publishes it.",
+				default: "",
+				required: !0,
+				label: "Action"
+			},
+			input: {
+				type: "text",
+				description: "The values passed to the action, as a JSON object. The server drops every key the action did not declare. Authoring in code, pass a real object rather than a line of JSON text — an interpolated value containing a quote or a newline makes the text unparseable, and unparseable input posts nothing.",
+				default: "{}",
+				builderType: "codemirror-json",
+				label: "Input"
+			},
+			mode: {
+				type: "select",
+				description: "await waits and puts the result in the flow scope; detached carries on immediately and leaves nothing to read; stream reports progress as it goes.",
+				default: "await",
+				options: [
+					"await",
+					"detached",
+					"stream"
+				],
+				optionLabels: {
+					await: "Wait for the result",
+					detached: "Send and continue",
+					stream: "Stream progress"
+				}
+			},
+			idempotencyKey: {
+				type: "text",
+				description: "Makes a repeat of the same intent answer with the first run instead of running again.",
+				default: "",
+				when: (e) => e.mode !== "detached"
+			}
+		},
+		preview: {
+			runId: "",
+			status: "",
+			output: {}
+		}
+	},
+	cancelServerAction: {
+		source: "actions",
+		title: "Cancel Server Action",
+		strictParams: !0,
+		params: { runId: {
+			type: "text",
+			description: "The run to cancel — normally `{{ <step>.output.runId }}` from the step that started it.",
+			default: ""
+		} },
+		preview: { cancelled: "" }
+	}
+};
+//#endregion
+export { e as actionsCallbacks };

package/dist/sources/ActionsSource/index.d.ts

@@ -0,0 +1,3 @@
+import { default as ActionInteractions } from './ActionInteractions';
+export * from './ActionInteractions';
+export { ActionInteractions };

package/dist/sources/ActionsSource/index.mjs

@@ -0,0 +1,2 @@
+import e from "./ActionInteractions.mjs";
+export { e as ActionInteractions };

package/dist/sources/AuthSource/AuthInteractions.mjs

@@ -1,101 +1,24 @@
 import e from "../../InteractionsContext.mjs";
-import { use as t, useCallback as n, useMemo as r } from "react";
-import { AuthContext as i } from "@plitzi/sdk-auth";
+import { authCallbacks as t } from "./callbacks.mjs";
+import { use as n, useCallback as r, useMemo as i } from "react";
+import { toInteractionCallbacks as a } from "@plitzi/sdk-shared/authoring/builder";
+import { AuthContext as o } from "@plitzi/sdk-auth";
 //#region src/sources/AuthSource/AuthInteractions.tsx
-var a = ({ children: a, authProvider: o = "basic" }) => {
-	let { login: s, refresh: c, logout: l } = t(i), { useInteractions: u } = t(e), d = n((e) => s(e), [s]), f = n((e) => c(e), [c]), p = n(() => l(), [l]);
-	return u({
+var s = ({ children: s, authProvider: c = "basic" }) => {
+	let { login: l, refresh: u, logout: d } = n(o), { useInteractions: f } = n(e), p = r((e) => l(e), [l]), m = r((e) => u(e), [u]), h = r(() => d(), [d]);
+	return f({
 		id: "auth",
-		callbacks: r(() => o === "" ? {} : {
-			login: {
-				action: "authLogin",
-				title: "Auth Login",
-				type: "globalCallback",
-				callback: d,
-				params: {
-					mode: {
-						label: "Mode",
-						canBind: !1,
-						type: "select",
-						defaultValue: "normal",
-						options: [{
-							label: "Token",
-							value: "token"
-						}, {
-							label: "User and Password",
-							value: "normal"
-						}]
-					},
-					username: {
-						type: "text",
-						defaultValue: "",
-						when: (e) => e.mode === "normal"
-					},
-					password: {
-						type: "text",
-						defaultValue: "",
-						when: (e) => e.mode === "normal"
-					},
-					token: {
-						type: "text",
-						defaultValue: "",
-						when: (e) => e.mode === "token"
-					}
-				},
-				preview: {
-					errors: {
-						username: "",
-						password: "",
-						token: ""
-					},
-					success: "",
-					access_token: "",
-					expires_at: "",
-					details: {
-						id: "",
-						username: "",
-						email: "",
-						verified: "",
-						permissions: ""
-					}
-				}
-			},
-			refreshDetails: {
-				action: "authRefreshDetails",
-				title: "Auth Refresh Details",
-				type: "globalCallback",
-				callback: f,
-				params: {},
-				preview: {
-					errors: "",
-					success: "",
-					access_token: "",
-					expires_at: "",
-					details: {
-						id: "",
-						username: "",
-						email: "",
-						roles: "",
-						permissions: "",
-						verified: ""
-					}
-				}
-			},
-			logout: {
-				action: "authLogout",
-				title: "Auth Logout",
-				type: "globalCallback",
-				callback: p,
-				preview: {},
-				params: {}
-			}
-		}, [
-			d,
+		callbacks: i(() => c === "" ? {} : a(t, {
+			login: p,
+			refreshDetails: m,
+			logout: h
+		}), [
 			p,
-			f,
-			o
+			h,
+			m,
+			c
 		])
-	}), a;
+	}), s;
 };
 //#endregion
-export { a as default };
+export { s as default };

package/dist/sources/AuthSource/callbacks.d.ts

@@ -0,0 +1,32 @@
+import { BuiltinGlobalCallback } from '@plitzi/sdk-shared/authoring/builder';
+/**
+ * The auth source's three actions.
+ *
+ * The KEY of each entry is the name a document names it by — `auth.login`, not `auth.authLogin`. That is not a
+ * cosmetic choice: `InteractionsManager` registers a callback under the key it is handed and `InteractionsHelper`
+ * resolves a step as `callbacksAvailables[<source>][<action>]`, so a catalog key that differs from the
+ * registration key is a step that resolves to nothing. These three used to be declared as `authLogin`,
+ * `authLogout` and `authRefreshDetails` while the source registered them as `login`, `logout` and
+ * `refreshDetails`, and every flow written from the catalog silently did nothing. {@link toInteractionCallbacks}
+ * is what makes the two the same string now.
+ *
+ * The names carry no provider in them on purpose. A space names `auth.login` whether the session is verified by
+ * Plitzi or by a self-hosted server's own accounts — the three calls are the auth context's, and every provider
+ * implements them.
+ *
+ * `login` takes four params, and the catalog that used to mirror this said it took none — an agent authoring a
+ * sign-in flow was told the credentials had nowhere to go. One declaration is what stops that from being possible.
+ *
+ * The previews matter as much as the params: they are the shape of what lands in the flow scope, so a step written
+ * after a login can read `{{ login.accessToken }}` because this says the key exists. That makes a preview which does
+ * not match what the callback RETURNS worse than no preview at all — and these did not: they promised
+ * `access_token`, `success` and a `details` object, while `AuthContext.login` has always answered with a
+ * {@link TokenResult}. Every sign-in flow written from this catalog therefore guarded on a key that is never there,
+ * and the shape of that failure is a login which succeeds — cookies and all — while the page insists the
+ * credentials were wrong and never goes anywhere.
+ *
+ * There is no user on a `TokenResult`, deliberately: who the session belongs to is loaded separately and arrives on
+ * the `auth` source, not out of this step. A flow that wants to greet somebody by name reads what they typed, or
+ * reads `auth.user` on a later render.
+ */
+export declare const authCallbacks: Record<string, BuiltinGlobalCallback>;