@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/WorkflowEngine-DJ6M4opp.mjs

@@ -0,0 +1,569 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { l as getRoutingState, o as getEffectivePrerequisites } from "./ToolRouter.policy-BGDAGyeH.mjs";
+import { randomUUID } from "node:crypto";
+//#region src/server/workflows/WorkflowDataBus.ts
+/**
+* Cross-node data bus for dynamic parameter passing.
+*
+* Supports expression templates like "${get-requests.scriptId}" to reference
+* outputs from previous steps.
+*/
+var WorkflowDataBus = class {
+	store = /* @__PURE__ */ new Map();
+	set(key, value) {
+		this.store.set(key, value);
+	}
+	get(key) {
+		return this.store.get(key);
+	}
+	getValueAtPath(key, path) {
+		const value = this.store.get(key);
+		if (!value || typeof value !== "object") return value;
+		const obj = parseToolPayload(value) || value;
+		return path.split(".").reduce((current, segment) => {
+			if (current && typeof current === "object") {
+				const arrayMatch = segment.match(/^(\d+)$/);
+				if (arrayMatch && Array.isArray(current)) return current[Number(arrayMatch[1])];
+				return current[segment];
+			}
+		}, obj);
+	}
+	resolve(template) {
+		const match = template.match(/^\$\{(.+)\}$/);
+		if (!match || !match[1]) return template;
+		const ref = match[1];
+		const dotIndex = ref.indexOf(".");
+		if (dotIndex === -1) return this.store.get(ref);
+		return this.getValueAtPath(ref.slice(0, dotIndex), ref.slice(dotIndex + 1));
+	}
+};
+function parseToolPayload(response) {
+	if (!response || typeof response !== "object") return;
+	const text = response.content?.find((item) => item.type === "text")?.text;
+	if (typeof text !== "string") return;
+	try {
+		const parsed = JSON.parse(text);
+		return parsed && typeof parsed === "object" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function responseIndicatesFailure(response) {
+	if (!response || typeof response !== "object") return;
+	if (response.isError) return "Tool returned MCP error response";
+	const payload = parseToolPayload(response);
+	if (payload?.success === false) return typeof payload.error === "string" ? payload.error : "Tool reported success=false";
+}
+function collectSuccessStats(value) {
+	if (Array.isArray(value)) return value.reduce((acc, item) => {
+		const next = collectSuccessStats(item);
+		acc.success += next.success;
+		acc.failure += next.failure;
+		return acc;
+	}, {
+		success: 0,
+		failure: 0
+	});
+	if (!value || typeof value !== "object") return {
+		success: 0,
+		failure: 0
+	};
+	const obj = value;
+	if (Array.isArray(obj["__order"])) return obj["__order"].reduce((acc, key) => {
+		const next = collectSuccessStats(obj[key]);
+		acc.success += next.success;
+		acc.failure += next.failure;
+		return acc;
+	}, {
+		success: 0,
+		failure: 0
+	});
+	const payload = parseToolPayload(value);
+	if (payload?.success === true) return {
+		success: 1,
+		failure: 0
+	};
+	/* istanbul ignore next */
+	if (payload?.success === false) return {
+		success: 0,
+		failure: 1
+	};
+	if ("error" in obj) return {
+		success: 0,
+		failure: 1
+	};
+	return {
+		success: 0,
+		failure: 0
+	};
+}
+function resolveInputFrom(mapping, dataBus) {
+	const resolved = {};
+	for (const [targetKey, sourceRef] of Object.entries(mapping)) {
+		const template = sourceRef.startsWith("${") ? sourceRef : `\${${sourceRef}}`;
+		resolved[targetKey] = dataBus.resolve(template);
+	}
+	return resolved;
+}
+function resolveInputValues(input, dataBus) {
+	if (!input) return {};
+	const resolved = {};
+	for (const [key, value] of Object.entries(input)) resolved[key] = resolveValue(value, dataBus);
+	return resolved;
+}
+function resolveValue(value, dataBus) {
+	if (typeof value === "string") return dataBus.resolve(value);
+	if (Array.isArray(value)) return value.map((item) => resolveValue(item, dataBus));
+	if (value && typeof value === "object") {
+		const resolved = {};
+		for (const [key, nestedValue] of Object.entries(value)) resolved[key] = resolveValue(nestedValue, dataBus);
+		return resolved;
+	}
+	return value;
+}
+//#endregion
+//#region src/server/workflows/WorkflowPredicates.ts
+function getWorkflowVariable(stepResults, keyPath) {
+	if (stepResults.has(keyPath)) return stepResults.get(keyPath);
+	const [stepId, ...fieldSegments] = keyPath.split(".");
+	if (!stepId || !stepResults.has(stepId)) return;
+	let current = stepResults.get(stepId);
+	if (current && typeof current === "object") {
+		const payload = parseToolPayload(current);
+		if (payload) current = payload;
+	}
+	for (const segment of fieldSegments) {
+		if (current && typeof current === "object") {
+			const arrayMatch = segment.match(/^(\d+)$/);
+			if (arrayMatch && Array.isArray(current)) {
+				current = current[Number(arrayMatch[1])];
+				continue;
+			}
+			current = current[segment];
+			continue;
+		}
+		return;
+	}
+	return current;
+}
+function deepEquals(left, right) {
+	if (left === right) return true;
+	if (typeof left !== typeof right) return false;
+	if (left && right && typeof left === "object" && typeof right === "object") {
+		if (Array.isArray(left) !== Array.isArray(right)) return false;
+		if (Array.isArray(left)) {
+			const leftArray = left;
+			const rightArray = right;
+			return leftArray.length === rightArray.length && leftArray.every((value, index) => deepEquals(value, rightArray[index]));
+		}
+		const leftKeys = Object.keys(left);
+		const rightKeys = Object.keys(right);
+		if (leftKeys.length !== rightKeys.length) return false;
+		return leftKeys.every((key) => deepEquals(left[key], right[key]));
+	}
+	return false;
+}
+async function evaluatePredicate(node, ctx) {
+	if (node.predicateFn) return await node.predicateFn(ctx);
+	if (node.predicateId === "always_true") return true;
+	if (node.predicateId === "always_false") return false;
+	if (node.predicateId === "any_step_failed") return [...ctx.stepResults.values()].some((value) => collectSuccessStats(value).failure > 0);
+	const successRateMatch = node.predicateId.match(/success_rate_gte_(\d+)/i);
+	if (successRateMatch?.[1]) {
+		const threshold = Number(successRateMatch[1]);
+		const aggregate = [...ctx.stepResults.values()].reduce((acc, value) => {
+			const next = collectSuccessStats(value);
+			acc.success += next.success;
+			acc.failure += next.failure;
+			return acc;
+		}, {
+			success: 0,
+			failure: 0
+		});
+		const total = aggregate.success + aggregate.failure;
+		return total > 0 && aggregate.success / total >= threshold / 100;
+	}
+	const equalsMatch = node.predicateId.match(/^variable_equals_(.+?)_(.+)$/);
+	if (equalsMatch?.[1] && equalsMatch[2]) return deepEquals(getWorkflowVariable(ctx.stepResults, equalsMatch[1]), equalsMatch[2]);
+	const containsMatch = node.predicateId.match(/^variable_contains_(.+?)_(.+)$/);
+	if (containsMatch?.[1] && containsMatch[2]) {
+		const value = getWorkflowVariable(ctx.stepResults, containsMatch[1]);
+		if (typeof value !== "string" && !Array.isArray(value)) return false;
+		return String(value).includes(containsMatch[2]);
+	}
+	const matchesMatch = node.predicateId.match(/^variable_matches_(.+?)_(.+)$/);
+	if (matchesMatch?.[1] && matchesMatch[2]) {
+		const value = getWorkflowVariable(ctx.stepResults, matchesMatch[1]);
+		if (typeof value !== "string") return false;
+		try {
+			return new RegExp(matchesMatch[2]).test(value);
+		} catch {
+			return false;
+		}
+	}
+	throw new Error(`Unknown workflow predicateId "${node.predicateId}"`);
+}
+//#endregion
+//#region src/server/workflows/WorkflowPreflight.ts
+function collectToolNodes(node) {
+	switch (node.kind) {
+		case "tool": return [node];
+		case "sequence":
+		case "parallel": return node.steps.flatMap((step) => collectToolNodes(step));
+		case "branch": return [...collectToolNodes(node.whenTrue), ...node.whenFalse ? collectToolNodes(node.whenFalse) : []];
+		case "fallback": return [...collectToolNodes(node.primary), ...collectToolNodes(node.fallback)];
+		default: return [];
+	}
+}
+function getEvidenceState(ctx) {
+	try {
+		const evidenceGraph = ctx.getDomainInstance("evidenceGraph");
+		return evidenceGraph ? {
+			hasGraph: true,
+			nodeCount: evidenceGraph.nodeCount,
+			edgeCount: evidenceGraph.edgeCount
+		} : {
+			hasGraph: false,
+			nodeCount: 0,
+			edgeCount: 0
+		};
+	} catch {
+		return {
+			hasGraph: false,
+			nodeCount: 0,
+			edgeCount: 0
+		};
+	}
+}
+function collectUnsatisfiedPrerequisites(graph, routingState) {
+	const prerequisites = getEffectivePrerequisites();
+	const warnings = [];
+	for (const toolNode of collectToolNodes(graph)) {
+		const toolPrerequisites = prerequisites[toolNode.toolName] ?? [];
+		for (const prerequisite of toolPrerequisites) {
+			if (prerequisite.check(routingState)) continue;
+			warnings.push({
+				nodeId: toolNode.id,
+				toolName: toolNode.toolName,
+				condition: prerequisite.condition,
+				fix: prerequisite.fix
+			});
+		}
+	}
+	return warnings;
+}
+//#endregion
+//#region src/server/workflows/WorkflowRunStore.ts
+var WorkflowRunStore = class {
+	runs = /* @__PURE__ */ new Map();
+	lastSuccess = /* @__PURE__ */ new Map();
+	recordSuccess(result) {
+		const entry = {
+			workflowId: result.workflowId,
+			runId: result.runId,
+			startedAt: result.startedAt,
+			finishedAt: result.finishedAt,
+			durationMs: result.durationMs,
+			status: "success",
+			stepResultKeys: Object.keys(result.stepResults)
+		};
+		this.runs.set(result.runId, entry);
+		this.lastSuccess.set(result.workflowId, result);
+		logger.debug(`workflow run recorded: ${result.runId} (${result.workflowId})`);
+	}
+	recordError(workflowId, runId, startedAt, error) {
+		const entry = {
+			workflowId,
+			runId,
+			startedAt,
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: Date.now() - new Date(startedAt).getTime(),
+			status: "error",
+			stepResultKeys: []
+		};
+		this.runs.set(runId, entry);
+		logger.debug(`workflow run error: ${runId} (${workflowId}): ${error}`);
+	}
+	getRun(runId) {
+		return this.runs.get(runId);
+	}
+	getLastSuccess(workflowId) {
+		return this.lastSuccess.get(workflowId);
+	}
+	listRuns(workflowId) {
+		const entries = [...this.runs.values()];
+		if (workflowId) return entries.filter((e) => e.workflowId === workflowId);
+		return entries;
+	}
+	clear() {
+		this.runs.clear();
+		this.lastSuccess.clear();
+	}
+};
+//#endregion
+//#region src/server/workflows/WorkflowEngine.types.ts
+var PreflightError = class extends Error {
+	constructor(warnings) {
+		super(`Workflow preflight failed with ${warnings.length} unsatisfied prerequisite(s)`);
+		this.warnings = warnings;
+		this.name = "PreflightError";
+	}
+};
+//#endregion
+//#region src/server/workflows/WorkflowEngine.ts
+var WorkflowEngine_exports = /* @__PURE__ */ __exportAll({ executeExtensionWorkflow: () => executeExtensionWorkflow });
+const globalRunStore = new WorkflowRunStore();
+function extractConfigValue(config, path, fallback) {
+	const segments = path.split(".").filter(Boolean);
+	let current = config;
+	for (const segment of segments) {
+		if (!current || typeof current !== "object") return fallback;
+		current = current[segment];
+	}
+	return current ?? fallback;
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeoutMs, label) {
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return promise;
+	return new Promise((resolve, reject) => {
+		const timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timeoutId);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timeoutId);
+			reject(error);
+		});
+	});
+}
+async function runToolNode(ctx, node, overrides, executionContext) {
+	const fromResolved = node.inputFrom ? resolveInputFrom(node.inputFrom, executionContext.dataBus) : {};
+	const mergedInput = {
+		...node.input ? resolveInputValues(node.input, executionContext.dataBus) : {},
+		...fromResolved,
+		...overrides?.[node.id]
+	};
+	const runAttempt = async () => {
+		const response = await withTimeout(ctx.executeToolWithTracking(node.toolName, mergedInput), node.timeoutMs ?? 0, `Workflow tool node "${node.id}"`);
+		const failure = responseIndicatesFailure(response);
+		if (failure) throw new Error(failure);
+		executionContext.dataBus.set(node.id, response);
+		return response;
+	};
+	const retry = node.retry;
+	if (!retry) return runAttempt();
+	let attempt = 0;
+	let backoffMs = retry.backoffMs;
+	while (attempt < retry.maxAttempts) try {
+		return await runAttempt();
+	} catch (error) {
+		attempt += 1;
+		if (attempt >= retry.maxAttempts) throw error;
+		await sleep(backoffMs);
+		backoffMs = Math.max(0, Math.floor(backoffMs * (retry.multiplier ?? 1)));
+	}
+	throw new Error(`Workflow tool node "${node.id}" exhausted retries`);
+}
+async function runParallelNode(ctx, node, executionContext, options) {
+	const concurrency = Math.max(1, node.maxConcurrency ?? 4);
+	const keyedResults = { __order: [] };
+	let nextIndex = 0;
+	let stopped = false;
+	const worker = async () => {
+		while (true) {
+			if (stopped) return;
+			const currentIndex = nextIndex;
+			nextIndex += 1;
+			if (currentIndex >= node.steps.length) return;
+			const step = node.steps[currentIndex];
+			/* istanbul ignore next */
+			if (!step) return;
+			try {
+				const result = await executeNode(ctx, step, executionContext, options);
+				keyedResults[step.id] = result;
+				keyedResults.__order.push(step.id);
+			} catch (error) {
+				if (node.failFast) {
+					stopped = true;
+					throw error;
+				}
+				keyedResults[step.id] = {
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				};
+				keyedResults.__order.push(step.id);
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, node.steps.length) }, () => worker()));
+	return keyedResults;
+}
+async function executeNode(ctx, node, executionContext, options) {
+	executionContext.emitSpan("workflow.node.start", {
+		nodeId: node.id,
+		kind: node.kind
+	});
+	let result;
+	switch (node.kind) {
+		case "tool":
+			result = await runToolNode(ctx, node, options.nodeInputOverrides, executionContext);
+			break;
+		case "sequence": {
+			const sequenceNode = node;
+			const items = [];
+			for (const step of sequenceNode.steps) items.push(await executeNode(ctx, step, executionContext, options));
+			result = items;
+			break;
+		}
+		case "parallel":
+			result = await runParallelNode(ctx, node, executionContext, options);
+			break;
+		case "branch": {
+			const branchNode = node;
+			const selected = await evaluatePredicate(branchNode, executionContext) ? branchNode.whenTrue : branchNode.whenFalse;
+			if (selected) result = await executeNode(ctx, selected, executionContext, options);
+			else result = void 0;
+			break;
+		}
+		case "fallback": {
+			const fallbackNode = node;
+			try {
+				result = await executeNode(ctx, fallbackNode.primary, executionContext, options);
+			} catch (error) {
+				executionContext.emitSpan("workflow.node.fallback", {
+					nodeId: fallbackNode.id,
+					primaryNodeId: fallbackNode.primary.id,
+					fallbackNodeId: fallbackNode.fallback.id,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				result = await executeNode(ctx, fallbackNode.fallback, executionContext, options);
+			}
+			break;
+		}
+		default: throw new Error(`Unsupported workflow node kind: ${node.kind}`);
+	}
+	executionContext.stepResults.set(node.id, result);
+	executionContext.emitSpan("workflow.node.finish", {
+		nodeId: node.id,
+		kind: node.kind
+	});
+	return result;
+}
+async function executeExtensionWorkflow(ctx, workflow, options = {}) {
+	const runId = randomUUID();
+	const profile = options.profile ?? String(ctx.baseTier ?? "workflow");
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const startedAtMs = Date.now();
+	const metrics = [];
+	const spans = [];
+	const stepResults = /* @__PURE__ */ new Map();
+	const dataBus = new WorkflowDataBus();
+	const mergedConfig = options.config ? {
+		...ctx.config,
+		...options.config
+	} : ctx.config;
+	const executionContext = {
+		workflowRunId: runId,
+		profile,
+		stepResults,
+		dataBus,
+		invokeTool(toolName, args) {
+			return ctx.executeToolWithTracking(toolName, args);
+		},
+		emitSpan(name, attrs) {
+			spans.push({
+				name,
+				attrs,
+				at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		},
+		emitMetric(name, value, type, attrs) {
+			metrics.push({
+				name,
+				value,
+				type,
+				attrs,
+				at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		},
+		getConfig(path, fallback) {
+			return extractConfigValue(mergedConfig, path, fallback);
+		}
+	};
+	try {
+		await workflow.onStart?.(executionContext);
+		const graph = workflow.build(executionContext);
+		const preflightMode = options.preflightMode ?? "warn";
+		let preflightWarnings = [];
+		if (preflightMode === "skip") executionContext.emitSpan("workflow.preflight", {
+			mode: preflightMode,
+			skipped: true,
+			evidenceState: getEvidenceState(ctx),
+			warningCount: 0
+		});
+		else try {
+			const routingState = await getRoutingState(ctx);
+			const evidenceState = getEvidenceState(ctx);
+			preflightWarnings = collectUnsatisfiedPrerequisites(graph, routingState);
+			executionContext.emitSpan("workflow.preflight", {
+				mode: preflightMode,
+				routingState,
+				evidenceState,
+				warningCount: preflightWarnings.length,
+				warnings: preflightWarnings
+			});
+			if (preflightMode === "strict" && preflightWarnings.length > 0) throw new PreflightError(preflightWarnings);
+		} catch (error) {
+			if (error instanceof PreflightError) throw error;
+			executionContext.emitSpan("workflow.preflight", {
+				mode: preflightMode,
+				warningCount: 0,
+				skipped: true,
+				error: error instanceof Error ? error.message : String(error),
+				evidenceState: getEvidenceState(ctx)
+			});
+		}
+		const result = await withTimeout(executeNode(ctx, graph, executionContext, options), options.timeoutMs ?? workflow.timeoutMs ?? 0, `Workflow "${workflow.id}"`);
+		await workflow.onFinish?.(executionContext, result);
+		try {
+			const evidenceGraph = typeof ctx.getDomainInstance === "function" ? ctx.getDomainInstance("evidenceGraph") : void 0;
+			if (evidenceGraph && evidenceGraph.nodeCount > 0) {
+				stepResults.set("__evidenceSnapshot", evidenceGraph.exportJson());
+				executionContext.emitSpan("workflow.evidence.auto-export", {
+					nodeCount: evidenceGraph.nodeCount,
+					edgeCount: evidenceGraph.edgeCount
+				});
+			}
+		} catch (exportError) {
+			executionContext.emitSpan("workflow.evidence.auto-export", {
+				skipped: true,
+				error: exportError instanceof Error ? exportError.message : String(exportError)
+			});
+		}
+		const runResult = {
+			workflowId: workflow.id,
+			displayName: workflow.displayName,
+			runId,
+			profile,
+			startedAt,
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: Date.now() - startedAtMs,
+			result,
+			stepResults: Object.fromEntries(stepResults.entries()),
+			metrics,
+			spans
+		};
+		globalRunStore.recordSuccess(runResult);
+		return runResult;
+	} catch (error) {
+		const workflowError = error instanceof Error ? error : new Error(String(error));
+		globalRunStore.recordError(workflow.id, runId, startedAt, workflowError);
+		await workflow.onError?.(executionContext, workflowError);
+		throw workflowError;
+	}
+}
+//#endregion
+export { executeExtensionWorkflow as n, WorkflowEngine_exports as t };