@powerhousedao/reactor-workflow 6.2.3-dev.11

package/dist/worker-entry.js

@@ -0,0 +1,605 @@
+import { A as REACTOR_MODEL, C as jsonSafe, D as REACTOR_EXECUTE, E as REACTOR_CREATE, F as UnsupportedContextMemberError, I as throwingStub, L as withTouchTracking, M as STORE_DELETE, N as STORE_GET, O as REACTOR_FIND, P as STORE_PUT, R as getActions, S as buildActionContext, T as OUTPUT_UPDATE, a as redactMessage, b as InMemoryConnectionsProvider, d as buildTriggerContext, h as StagedFilesService, i as redactError, j as REACTOR_MODELS, k as REACTOR_GET, l as installEgressGuard, m as DataUriFilesService, p as runTriggerHook, u as runWithEgressPolicy, v as assertWithinLimit, w as LOG_WRITE, x as InMemoryKeyValueStore, y as maxFileBytes, z as getTriggers } from "./redact-C7LWgAyD.js";
+import { i as loadPieceFromDir, n as describeProperties, r as loadPiece, t as buildDescriptor } from "./descriptor-DXbWuxhE.js";
+import { readFile } from "node:fs/promises";
+import { format } from "node:util";
+import { arrayZipperProcessor, formatPieceError, processors } from "@powerhousedao/pieces-framework/host";
+//#region src/pieces/activepieces/worker/host-call.ts
+const DEFAULT_HOST_CALL_TIMEOUT_MS = 1e4;
+const pending = /* @__PURE__ */ new Map();
+let nextId = 1;
+let listening = false;
+var HostCallError = class extends Error {
+	constructor(method, detail) {
+		super(`Host call "${method}" failed: ${detail}`);
+		this.name = "HostCallError";
+	}
+};
+var HostCallTimeoutError = class extends Error {
+	constructor(method, timeoutMs) {
+		super(`Host call "${method}" got no answer within ${timeoutMs}ms`);
+		this.name = "HostCallTimeoutError";
+	}
+};
+function isHostCallResponse(value) {
+	return typeof value === "object" && value !== null && value.type === "host-result";
+}
+function ensureListening() {
+	if (listening) return;
+	listening = true;
+	process.on("message", (message) => {
+		if (!isHostCallResponse(message)) return;
+		const entry = pending.get(message.id);
+		if (!entry) return;
+		pending.delete(message.id);
+		clearTimeout(entry.timer);
+		if (message.error !== void 0) {
+			entry.reject(new HostCallError(entry.method, message.error));
+			return;
+		}
+		entry.resolve(message.value);
+	});
+}
+function callHost(method, payload, timeoutMs = DEFAULT_HOST_CALL_TIMEOUT_MS) {
+	if (!process.send) return Promise.reject(new HostCallError(method, "the worker has no channel to its host"));
+	ensureListening();
+	const id = nextId++;
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			pending.delete(id);
+			reject(new HostCallTimeoutError(method, timeoutMs));
+		}, timeoutMs);
+		pending.set(id, {
+			method,
+			resolve,
+			reject,
+			timer
+		});
+		process.send?.({
+			id,
+			type: "host-call",
+			method,
+			payload
+		});
+	});
+}
+function notifyHost(method, payload) {
+	try {
+		process.send?.({
+			type: "host-notify",
+			method,
+			payload
+		});
+	} catch {}
+}
+//#endregion
+//#region src/pieces/activepieces/context/reactor.ts
+var RemoteReactorService = class {
+	models() {
+		return callHost(REACTOR_MODELS, {});
+	}
+	model(documentType) {
+		return callHost(REACTOR_MODEL, { documentType });
+	}
+	get(input) {
+		return callHost(REACTOR_GET, input);
+	}
+	find(input) {
+		return callHost(REACTOR_FIND, input);
+	}
+	create(input) {
+		return callHost(REACTOR_CREATE, input);
+	}
+	execute(input) {
+		return callHost(REACTOR_EXECUTE, input);
+	}
+};
+//#endregion
+//#region src/pieces/activepieces/context/check.ts
+function buildCheckConnectionContext(options = {}) {
+	const touched = /* @__PURE__ */ new Set();
+	return {
+		context: withTouchTracking({
+			auth: options.auth,
+			server: options.server ? {
+				...options.server,
+				mintOidcToken: throwingStub("server.mintOidcToken")
+			} : throwingStub("server")
+		}, touched, options.onTouch),
+		touched
+	};
+}
+//#endregion
+//#region src/pieces/activepieces/context/normalize.ts
+const FETCH_TIMEOUT_MS = 3e4;
+const FILE_REF = /^(?:attachment|apfile):\/\//i;
+var FileFetchError = class extends Error {
+	constructor(url, reason) {
+		super(`Could not fetch FILE prop "${url}": ${reason}`);
+		this.name = "FileFetchError";
+	}
+};
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const DATA_URI = /^data:([^;,]*)((?:;[^;,]*)*),([\s\S]*)$/;
+function extensionOf(filename) {
+	const dot = filename.lastIndexOf(".");
+	return dot > 0 && dot < filename.length - 1 ? filename.slice(dot + 1) : void 0;
+}
+const MIME_EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/svg+xml": "svg",
+	"application/pdf": "pdf",
+	"application/json": "json",
+	"text/plain": "txt",
+	"text/csv": "csv"
+};
+function toFileValue(data, filename, contentType) {
+	const mime = contentType?.split(";")[0].trim().toLowerCase();
+	const mimeExtension = mime ? MIME_EXTENSIONS[mime] : void 0;
+	const name = filename && filename !== "" ? filename : `file${mimeExtension ? `.${mimeExtension}` : ""}`;
+	const extension = extensionOf(name) ?? mimeExtension;
+	return {
+		filename: name,
+		...extension ? { extension } : {},
+		base64: data.toString("base64"),
+		data
+	};
+}
+function filenameFromDisposition(header) {
+	if (!header) return void 0;
+	const utf8 = /filename\*=(?:UTF-8'')?([^;]+)/i.exec(header);
+	if (utf8) try {
+		return decodeURIComponent(utf8[1].trim().replace(/^"|"$/g, ""));
+	} catch {}
+	const plain = /filename="?([^";]+)"?/i.exec(header);
+	return plain ? plain[1].trim() : void 0;
+}
+async function defaultFetchFile(url) {
+	let response;
+	try {
+		response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+	} catch (error) {
+		throw new FileFetchError(url, error instanceof Error ? error.message : String(error));
+	}
+	if (!response.ok) throw new FileFetchError(url, `HTTP ${response.status}`);
+	const limit = maxFileBytes();
+	const declared = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declared) && declared > limit) throw new FileFetchError(url, `${declared} bytes exceeds ${limit}`);
+	const data = Buffer.from(await response.arrayBuffer());
+	if (data.byteLength > limit) throw new FileFetchError(url, `${data.byteLength} bytes exceeds ${limit}`);
+	let filename = filenameFromDisposition(response.headers.get("content-disposition"));
+	if (!filename) {
+		const segment = new URL(url).pathname.split("/").filter(Boolean).pop();
+		if (segment) filename = decodeURIComponent(segment);
+	}
+	return {
+		data,
+		filename,
+		contentType: response.headers.get("content-type") ?? void 0
+	};
+}
+function isFileShaped(value) {
+	return isRecord(value) && typeof value.filename === "string" && (typeof value.base64 === "string" || Buffer.isBuffer(value.data));
+}
+async function toApFile(value, options = {}) {
+	if (isFileShaped(value)) {
+		const data = Buffer.isBuffer(value.data) ? value.data : Buffer.from(value.base64, "base64");
+		assertWithinLimit(data.byteLength);
+		const extension = value.extension ?? extensionOf(value.filename);
+		return {
+			...value,
+			...extension ? { extension } : {},
+			base64: typeof value.base64 === "string" ? value.base64 : data.toString("base64"),
+			data
+		};
+	}
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	const dataUri = DATA_URI.exec(trimmed);
+	if (dataUri) {
+		const [, mime, params, payload] = dataUri;
+		const data = /;base64/i.test(params) ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload), "utf8");
+		assertWithinLimit(data.byteLength);
+		const nameParam = /;name=([^;]+)/i.exec(params)?.[1];
+		return toFileValue(data, nameParam ? decodeURIComponent(nameParam) : void 0, mime || void 0);
+	}
+	if (FILE_REF.test(trimmed)) {
+		if (!options.resolveRef) throw new FileFetchError(trimmed, "no attachment resolver is available in this context");
+		const resolved = await options.resolveRef(trimmed);
+		assertWithinLimit(resolved.data.byteLength);
+		return toFileValue(resolved.data, resolved.filename, resolved.contentType);
+	}
+	if (/^https?:\/\//i.test(trimmed)) {
+		const fetched = await (options.fetchFile ?? defaultFetchFile)(trimmed);
+		return toFileValue(fetched.data, fetched.filename, fetched.contentType);
+	}
+	return value;
+}
+async function normalizeArray(prop, value, options) {
+	const fields = prop.properties;
+	if (!fields) return value;
+	const zipped = arrayZipperProcessor(prop, value);
+	if (!Array.isArray(zipped)) return value;
+	return Promise.all(zipped.map((item) => isRecord(item) ? normalizePropsValue(fields, item, options) : item));
+}
+function plainFile(value) {
+	if (!isRecord(value) || typeof value.filename !== "string") return value;
+	const { data } = value;
+	if (!Buffer.isBuffer(data)) return value;
+	const extension = typeof value.extension === "string" ? value.extension : extensionOf(value.filename);
+	return {
+		filename: value.filename,
+		...extension ? { extension } : {},
+		base64: typeof value.base64 === "string" ? value.base64 : data.toString("base64"),
+		data
+	};
+}
+const table = processors;
+async function normalizeValue(prop, value, options = {}) {
+	if (value === void 0 || value === null) return value;
+	if (prop.type === "ARRAY") return normalizeArray(prop, value, options);
+	if (prop.type === "FILE") {
+		const hydrated = await toApFile(value, options);
+		if (typeof hydrated !== "string") return hydrated;
+		return plainFile(await table.FILE?.(prop, hydrated));
+	}
+	const processor = prop.type ? table[prop.type] : void 0;
+	if (!processor) return value;
+	return plainFile(await processor(prop, value));
+}
+async function normalizePropsValue(props, values, options = {}) {
+	if (!props || !isRecord(values)) return values;
+	const out = { ...values };
+	for (const [name, prop] of Object.entries(props)) {
+		if (!(name in out) || !isRecord(prop)) continue;
+		const normalized = await normalizeValue(prop, out[name], options);
+		if (normalized === void 0) delete out[name];
+		else out[name] = normalized;
+	}
+	return out;
+}
+//#endregion
+//#region src/pieces/activepieces/context/props.ts
+function buildPropertyContext(options = {}) {
+	const touched = /* @__PURE__ */ new Set();
+	return {
+		context: withTouchTracking({
+			searchValue: options.searchValue,
+			reactor: options.reactor ?? throwingStub("reactor"),
+			server: options.server ?? throwingStub("server"),
+			project: {
+				id: options.projectId ?? "project",
+				externalId: () => Promise.resolve(options.projectId ?? "project")
+			},
+			flows: options.flows ?? { list: throwingStub("flows.list") },
+			connections: options.connections ?? { get: throwingStub("connections.get") }
+		}, touched, options.onTouch),
+		touched
+	};
+}
+var NotDynamicPropertyError = class extends Error {
+	constructor(actionName, propName) {
+		super(`Property "${actionName}.${propName}" has no dynamic resolver`);
+		this.name = "NotDynamicPropertyError";
+	}
+};
+function pickResolver(prop) {
+	if (typeof prop.options === "function") return prop.options;
+	if (typeof prop.props === "function") return prop.props;
+}
+function ownerProps(piece, actionName, kind = "action") {
+	const owner = kind === "trigger" ? getTriggers(piece)[actionName] : getActions(piece)[actionName];
+	if (!owner) throw new Error(`No ${kind} "${actionName}" on piece`);
+	return owner.props ?? {};
+}
+function findProperty(piece, actionName, propName, kind = "action") {
+	const prop = ownerProps(piece, actionName, kind)[propName];
+	if (!prop) throw new Error(`No prop "${propName}" on ${kind} "${actionName}"`);
+	return prop;
+}
+async function resolveDynamicProperty(params) {
+	const { piece, actionName, propName, kind = "action" } = params;
+	const resolver = pickResolver(findProperty(piece, actionName, propName, kind));
+	if (!resolver) throw new NotDynamicPropertyError(actionName, propName);
+	return await resolver(params.refresherValues ?? {}, params.context);
+}
+//#endregion
+//#region src/pieces/activepieces/context/remote-store.ts
+var RemoteKeyValueStore = class {
+	async put(key, value, scope) {
+		const stored = jsonSafe(value);
+		await callHost(STORE_PUT, {
+			key,
+			value: stored,
+			scope
+		});
+		return stored;
+	}
+	get(key, scope) {
+		return callHost(STORE_GET, {
+			key,
+			scope
+		});
+	}
+	async delete(key, scope) {
+		await callHost(STORE_DELETE, {
+			key,
+			scope
+		});
+	}
+};
+//#endregion
+//#region src/pieces/activepieces/context/remote-output.ts
+var RemoteOutput = class {
+	open = true;
+	update(output) {
+		if (this.open) notifyHost(OUTPUT_UPDATE, jsonSafe(output));
+		return Promise.resolve();
+	}
+	close() {
+		this.open = false;
+	}
+};
+//#endregion
+//#region src/pieces/activepieces/worker/logs.ts
+const MAX_MESSAGE_LENGTH = 8192;
+const MAX_ENTRIES_PER_REQUEST = 1e3;
+const LEVELS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug"
+];
+function captureConsole() {
+	const original = /* @__PURE__ */ new Map();
+	let sent = 0;
+	for (const level of LEVELS) {
+		const previous = console[level];
+		original.set(level, previous);
+		console[level] = (...args) => {
+			if (sent > MAX_ENTRIES_PER_REQUEST) return;
+			sent += 1;
+			notifyHost(LOG_WRITE, {
+				level,
+				message: sent > MAX_ENTRIES_PER_REQUEST ? `[log truncated after ${MAX_ENTRIES_PER_REQUEST} entries]` : format(...args).slice(0, MAX_MESSAGE_LENGTH),
+				at: Date.now()
+			});
+		};
+	}
+	return () => {
+		for (const [level, previous] of original) console[level] = previous;
+	};
+}
+//#endregion
+//#region src/pieces/activepieces/worker/entry.ts
+installEgressGuard();
+const loadedPieces = /* @__PURE__ */ new Map();
+const stores = /* @__PURE__ */ new Map();
+function storeForScope(scope) {
+	let store = stores.get(scope);
+	if (!store) {
+		store = new InMemoryKeyValueStore();
+		stores.set(scope, store);
+	}
+	return store;
+}
+function pieceRefKey(ref) {
+	const key = ref.entryPath ?? ref.bundleDir;
+	if (!key) throw new Error("Request names no piece module (entryPath or bundleDir)");
+	return key;
+}
+function loadCached(ref) {
+	const key = pieceRefKey(ref);
+	let loading = loadedPieces.get(key);
+	if (!loading) {
+		loading = ref.entryPath ? loadPiece(key) : loadPieceFromDir(key);
+		loadedPieces.set(key, loading);
+	}
+	return loading;
+}
+function redactValuesOf(message) {
+	return message.request.redactValues ?? [];
+}
+function serializeError(error, values = []) {
+	const properties = {};
+	if (typeof error === "object" && error !== null) for (const key of Object.keys(error)) properties[key] = jsonSafe(error[key]);
+	const { __apErrorVersion, message, errorName, ...http } = formatPieceError(error);
+	return {
+		name: typeof error === "object" && error !== null && error.constructor.name || errorName || "Error",
+		message: redactMessage(message, { values }),
+		properties: redactError({
+			...properties,
+			...jsonSafe(http)
+		}, { values }),
+		unsupportedMember: error instanceof UnsupportedContextMemberError ? error.member : void 0
+	};
+}
+function consumeTlsFlag() {
+	const poisoned = process.env.NODE_TLS_REJECT_UNAUTHORIZED === "0";
+	delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+	return poisoned;
+}
+async function handleResolveOptions(message) {
+	const { request } = message;
+	const { piece } = await loadCached(request);
+	const { context, touched } = buildPropertyContext({
+		searchValue: request.searchValue,
+		flows: { list: () => Promise.resolve({ data: [] }) },
+		...request.reactorAccess ? { reactor: new RemoteReactorService() } : {}
+	});
+	const refresherValues = {
+		...request.auth !== void 0 ? { auth: request.auth } : {},
+		...request.refresherValues
+	};
+	const prop = findProperty(piece, request.actionName, request.propName, request.kind);
+	const output = await resolveDynamicProperty({
+		piece,
+		actionName: request.actionName,
+		kind: request.kind,
+		propName: request.propName,
+		refresherValues,
+		context
+	});
+	const isDynamic = typeof prop.props === "function" && typeof prop.options !== "function";
+	return {
+		id: message.id,
+		type: "result",
+		output: isDynamic ? describeProperties(output) : jsonSafe(output),
+		touched: [...touched],
+		tlsPoisoned: consumeTlsFlag()
+	};
+}
+function stagedInputResolver(inputs) {
+	if (!inputs || inputs.length === 0) return void 0;
+	const byRef = new Map(inputs.map((input) => [input.ref, input]));
+	return async (ref) => {
+		const staged = byRef.get(ref);
+		if (!staged) throw new Error(`No staged file for reference "${ref}"`);
+		return {
+			data: await readFile(staged.path),
+			filename: staged.fileName,
+			contentType: staged.contentType
+		};
+	};
+}
+async function handleRun(message) {
+	const { request } = message;
+	const { piece } = await loadCached(request);
+	const action = getActions(piece)[request.actionName];
+	if (!action) throw new Error(`No action "${request.actionName}" in ${pieceRefKey(request)}`);
+	const files = request.stagingDir ? new StagedFilesService(request.stagingDir) : new DataUriFilesService();
+	const durableStore = request.durableStore ? new RemoteKeyValueStore() : void 0;
+	const liveOutput = request.liveOutput ? new RemoteOutput() : void 0;
+	const reactor = request.reactorAccess ? new RemoteReactorService() : void 0;
+	const { context, touched } = buildActionContext({
+		propsValue: await normalizePropsValue(action.props, request.propsValue, { resolveRef: stagedInputResolver(request.stagedInputs) }),
+		auth: request.auth,
+		store: durableStore ?? (request.storeScope ? storeForScope(request.storeScope) : void 0),
+		files,
+		connections: request.connections ? new InMemoryConnectionsProvider(request.connections) : void 0,
+		output: liveOutput,
+		reactor,
+		executionType: request.executionType,
+		identity: request.identity
+	});
+	const restoreConsole = request.captureLogs ? captureConsole() : void 0;
+	let output;
+	try {
+		output = await action.run(context);
+	} finally {
+		restoreConsole?.();
+		liveOutput?.close();
+	}
+	return {
+		id: message.id,
+		type: "result",
+		output: jsonSafe(output),
+		...files instanceof StagedFilesService && files.staged().length > 0 ? { files: files.staged() } : {},
+		touched: [...touched],
+		tlsPoisoned: consumeTlsFlag()
+	};
+}
+async function handleTriggerHook(message) {
+	const { request } = message;
+	const { piece } = await loadCached(request);
+	const trigger = getTriggers(piece)[request.triggerName];
+	if (!trigger) throw new Error(`No trigger "${request.triggerName}" in bundle ${request.bundleDir}`);
+	const snapshot = request.durableStore ? void 0 : new InMemoryKeyValueStore(request.storeState);
+	const runsPiece = request.hook === "run" || request.hook === "test";
+	const handle = buildTriggerContext({
+		propsValue: await normalizePropsValue(trigger.props, request.propsValue),
+		auth: request.auth,
+		store: snapshot ?? new RemoteKeyValueStore(),
+		hostPartitionedStore: request.durableStore,
+		storePrefix: request.hook === "test" ? "test" : "",
+		identity: request.identity,
+		isRepublish: request.isRepublish,
+		payload: request.payload,
+		webhookUrl: request.webhookUrl,
+		server: request.server,
+		files: runsPiece ? new DataUriFilesService() : void 0
+	});
+	const output = await runTriggerHook(trigger, request.hook, handle);
+	return {
+		id: message.id,
+		type: "result",
+		output: jsonSafe(output),
+		touched: [...handle.touched],
+		tlsPoisoned: consumeTlsFlag(),
+		...snapshot ? { storeState: jsonSafe(snapshot.snapshot()) } : {},
+		schedules: handle.schedules,
+		listeners: handle.listeners
+	};
+}
+async function handleCheckConnection(message) {
+	const { request } = message;
+	const { piece } = await loadCached(request);
+	const app = piece;
+	if (typeof app.checkConnection !== "function") return {
+		id: message.id,
+		type: "result",
+		output: { declared: false },
+		touched: [],
+		tlsPoisoned: consumeTlsFlag()
+	};
+	const { context, touched } = buildCheckConnectionContext({ auth: request.auth });
+	const outcome = {
+		declared: true,
+		result: jsonSafe(await app.checkConnection(context))
+	};
+	return {
+		id: message.id,
+		type: "result",
+		output: outcome,
+		touched: [...touched],
+		tlsPoisoned: consumeTlsFlag()
+	};
+}
+async function handleDescribe(message) {
+	const { request } = message;
+	const { piece } = await loadCached(request);
+	const descriptor = buildDescriptor(piece, {
+		packageName: request.packageName,
+		version: request.version
+	});
+	return {
+		id: message.id,
+		type: "result",
+		output: jsonSafe(descriptor),
+		touched: [],
+		tlsPoisoned: consumeTlsFlag()
+	};
+}
+function isWorkerMessage(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const type = value.type;
+	return type === "run" || type === "resolve-options" || type === "trigger-hook" || type === "check-connection" || type === "describe";
+}
+function dispatch(message) {
+	switch (message.type) {
+		case "run": return handleRun(message);
+		case "resolve-options": return handleResolveOptions(message);
+		case "trigger-hook": return handleTriggerHook(message);
+		case "check-connection": return handleCheckConnection(message);
+		case "describe": return handleDescribe(message);
+	}
+}
+process.on("message", (message) => {
+	if (!isWorkerMessage(message)) return;
+	Promise.resolve().then(() => runWithEgressPolicy(message.request.egress, () => dispatch(message))).catch((error) => ({
+		id: message.id,
+		type: "error",
+		error: serializeError(error, redactValuesOf(message)),
+		tlsPoisoned: consumeTlsFlag()
+	})).then((response) => process.send?.(response)).catch(() => process.exit(1));
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=worker-entry.js.map