@jshookmcp/jshook 0.3.0 → 0.3.1

package/dist/WorkflowEngine-DJ6M4opp.mjs

@@ -1,569 +0,0 @@
-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 };