@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/handlers-U6L4xhuF.mjs

@@ -1,585 +0,0 @@
-import { t as logger } from "./logger-Dh_xb7_2.mjs";
-import { _t as MACRO_BUILTIN_TIMEOUT_MS, vt as MACRO_DEFAULT_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
-import { i as getProjectRoot } from "./outputPaths-B1uGmrWZ.mjs";
-import { n as executeExtensionWorkflow } from "./WorkflowEngine-CuvkZtWu.mjs";
-import { extname, resolve } from "node:path";
-import { readFile, readdir } from "node:fs/promises";
-//#region src/server/workflows/WorkflowContract.ts
-function buildNode(node) {
-	return "kind" in node ? node : node.build();
-}
-function setup(target, fn) {
-	fn?.(target);
-	return target;
-}
-function createToolBuilder(id, toolName) {
-	const step = {};
-	let input;
-	let inputFrom;
-	let retry;
-	let timeoutMs;
-	step.input = (value) => {
-		input = value;
-		return step;
-	};
-	step.inputFrom = (value) => {
-		inputFrom = value;
-		return step;
-	};
-	step.retry = (value) => {
-		retry = value;
-		return step;
-	};
-	step.timeout = (value) => {
-		timeoutMs = value;
-		return step;
-	};
-	step.build = () => ({
-		kind: "tool",
-		id,
-		toolName,
-		input,
-		inputFrom,
-		retry,
-		timeoutMs
-	});
-	return step;
-}
-function applyToolConfig(step, config) {
-	if (!config) return step;
-	if (typeof config === "function") {
-		config(step);
-		return step;
-	}
-	if (config.input) step.input(config.input);
-	if (config.inputFrom) step.inputFrom(config.inputFrom);
-	if (config.retry) step.retry(config.retry);
-	if (config.timeoutMs !== void 0) step.timeout(config.timeoutMs);
-	return step;
-}
-function addSequenceMethods(step, steps) {
-	step.step = (node) => {
-		steps.push(node);
-		return step;
-	};
-	step.tool = (id, toolName, config) => {
-		steps.push(applyToolConfig(createToolBuilder(id, toolName), config));
-		return step;
-	};
-	step.sequence = (id, config) => {
-		steps.push(setup(createSequenceBuilder(id), config));
-		return step;
-	};
-	step.parallel = (id, config) => {
-		steps.push(setup(createParallelBuilder(id), config));
-		return step;
-	};
-	step.branch = (id, predicateId, config) => {
-		steps.push(setup(createBranchBuilder(id, predicateId), config));
-		return step;
-	};
-	step.fallback = (id, config) => {
-		steps.push(setup(createFallbackBuilder(id), config));
-		return step;
-	};
-	return step;
-}
-function createSequenceBuilder(id) {
-	const steps = [];
-	const step = addSequenceMethods({}, steps);
-	step.build = () => ({
-		kind: "sequence",
-		id,
-		steps: steps.map(buildNode)
-	});
-	return step;
-}
-function createParallelBuilder(id) {
-	const steps = [];
-	const step = addSequenceMethods({}, steps);
-	let maxConcurrency = 4;
-	let failFast = false;
-	step.maxConcurrency = (value) => {
-		maxConcurrency = value;
-		return step;
-	};
-	step.failFast = (value) => {
-		failFast = value;
-		return step;
-	};
-	step.build = () => ({
-		kind: "parallel",
-		id,
-		steps: steps.map(buildNode),
-		maxConcurrency,
-		failFast
-	});
-	return step;
-}
-function createBranchBuilder(id, predicateId) {
-	const step = {};
-	let predicateFn;
-	let whenTrue;
-	let whenFalse;
-	step.predicateFn = (value) => {
-		predicateFn = value;
-		return step;
-	};
-	step.whenTrue = (value) => {
-		whenTrue = value;
-		return step;
-	};
-	step.whenFalse = (value) => {
-		whenFalse = value;
-		return step;
-	};
-	step.build = () => {
-		if (!whenTrue) throw new Error(`BranchNode '${id}' requires a whenTrue step`);
-		return {
-			kind: "branch",
-			id,
-			predicateId,
-			predicateFn,
-			whenTrue: buildNode(whenTrue),
-			whenFalse: whenFalse ? buildNode(whenFalse) : void 0
-		};
-	};
-	return step;
-}
-function createFallbackBuilder(id) {
-	const step = {};
-	let primary;
-	let fallback;
-	step.primary = (value) => {
-		primary = value;
-		return step;
-	};
-	step.fallback = (value) => {
-		fallback = value;
-		return step;
-	};
-	step.build = () => {
-		if (!primary) throw new Error(`FallbackNode '${id}' requires a primary step`);
-		if (!fallback) throw new Error(`FallbackNode '${id}' requires a fallback step`);
-		return {
-			kind: "fallback",
-			id,
-			primary: buildNode(primary),
-			fallback: buildNode(fallback)
-		};
-	};
-	return step;
-}
-function createWorkflowBuilder(id, displayName) {
-	const workflow = {};
-	let description;
-	let tags;
-	let timeoutMs;
-	let defaultMaxConcurrency;
-	let route;
-	let buildGraph;
-	let onStart;
-	let onFinish;
-	let onError;
-	workflow.description = (value) => {
-		description = value;
-		return workflow;
-	};
-	workflow.tags = (value) => {
-		tags = value;
-		return workflow;
-	};
-	workflow.timeoutMs = (value) => {
-		timeoutMs = value;
-		return workflow;
-	};
-	workflow.defaultMaxConcurrency = (value) => {
-		defaultMaxConcurrency = value;
-		return workflow;
-	};
-	workflow.route = (value) => {
-		route = value;
-		return workflow;
-	};
-	workflow.buildGraph = (value) => {
-		buildGraph = value;
-		return workflow;
-	};
-	workflow.onStart = (value) => {
-		onStart = value;
-		return workflow;
-	};
-	workflow.onFinish = (value) => {
-		onFinish = value;
-		return workflow;
-	};
-	workflow.onError = (value) => {
-		onError = value;
-		return workflow;
-	};
-	workflow.build = () => {
-		if (!buildGraph) throw new Error(`Workflow '${id}' needs a buildGraph() function.`);
-		return {
-			kind: "workflow-contract",
-			version: 1,
-			id,
-			displayName,
-			description,
-			tags,
-			timeoutMs,
-			defaultMaxConcurrency,
-			route,
-			build: buildGraph,
-			onStart,
-			onFinish,
-			onError
-		};
-	};
-	return workflow;
-}
-function defineWorkflow(id, displayName, configure) {
-	const workflow = createWorkflowBuilder(id, displayName);
-	configure(workflow);
-	return workflow.build();
-}
-function toolStep(id, toolName, config) {
-	return applyToolConfig(createToolBuilder(id, toolName), config).build();
-}
-function sequenceStep(id, config) {
-	return setup(createSequenceBuilder(id), config).build();
-}
-//#endregion
-//#region src/server/macros/MacroRunner.ts
-/**
-* MacroRunner — Executes macro definitions using the WorkflowEngine.
-*
-* Wraps the existing WorkflowEngine + WorkflowContract infrastructure
-* to provide:
-* - Inline progress reporting: `[stage N/M] step_name — status (Xms)`
-* - Atomic bailout with partial result collection on step failure
-* - inputFrom data piping between sequential steps
-*/
-var MacroRunner = class {
-	ctx;
-	constructor(ctx) {
-		this.ctx = ctx;
-	}
-	/**
-	* Build a WorkflowContract from a MacroDefinition.
-	*/
-	buildWorkflowFromDefinition(def) {
-		return defineWorkflow(def.id, def.displayName, (w) => w.description(def.description).tags(def.tags).timeoutMs(def.timeoutMs ?? MACRO_DEFAULT_TIMEOUT_MS).buildGraph(() => sequenceStep(`${def.id}-root`, (seq) => {
-			for (const step of def.steps) seq.step(toolStep(step.id, step.toolName, (toolBuilder) => {
-				toolBuilder.input(step.input ?? {}).timeout(step.timeoutMs ?? 0);
-				if (step.inputFrom) toolBuilder.inputFrom(step.inputFrom);
-			}));
-		})).onStart((ctx) => {
-			ctx.emitSpan("macro.start", {
-				macroId: def.id,
-				totalSteps: def.steps.length
-			});
-		}).onError((_ctx, err) => {
-			_ctx.emitSpan("macro.error", {
-				macroId: def.id,
-				error: err.message
-			});
-		}));
-	}
-	/**
-	* Execute a macro definition with optional per-node input overrides.
-	*
-	* Returns a MacroResult with inline progress and partial results on failure.
-	*/
-	async execute(def, inputOverrides) {
-		const workflow = this.buildWorkflowFromDefinition(def);
-		const startMs = Date.now();
-		try {
-			const result = await executeExtensionWorkflow(this.ctx, workflow, { nodeInputOverrides: inputOverrides });
-			const progress = this._buildProgress(def, result.spans, result.stepResults);
-			return {
-				macroId: def.id,
-				displayName: def.displayName,
-				ok: true,
-				durationMs: result.durationMs,
-				stepsCompleted: def.steps.length,
-				totalSteps: def.steps.length,
-				stepResults: result.stepResults,
-				progress
-			};
-		} catch (err) {
-			const durationMs = Date.now() - startMs;
-			const error = err instanceof Error ? err.message : String(err);
-			const progress = this._buildPartialProgress(def, error);
-			return {
-				macroId: def.id,
-				displayName: def.displayName,
-				ok: false,
-				durationMs,
-				stepsCompleted: progress.filter((p) => p.status === "complete").length,
-				totalSteps: def.steps.length,
-				stepResults: {},
-				progress,
-				error
-			};
-		}
-	}
-	/**
-	* Format a MacroResult as inline MCP text with stage markers.
-	*/
-	formatProgressReport(result) {
-		const lines = [];
-		lines.push(`**Macro:** ${result.displayName} (\`${result.macroId}\`)`);
-		lines.push("");
-		for (const p of result.progress) {
-			const durStr = p.durationMs !== void 0 ? ` (${p.durationMs}ms)` : "";
-			const errStr = p.error ? `: ${p.error}` : "";
-			const icon = p.status === "complete" ? "✓" : p.status === "failed" ? "✗" : "○";
-			lines.push(`[stage ${p.step}/${p.totalSteps}] ${icon} ${p.stepName} — ${p.status}${durStr}${errStr}`);
-		}
-		lines.push("");
-		if (result.ok) lines.push(`✓ Macro complete (${result.stepsCompleted}/${result.totalSteps} steps, ${result.durationMs}ms)`);
-		else lines.push(`✗ Macro failed at step ${result.stepsCompleted + 1}/${result.totalSteps}: ${result.error ?? "unknown error"}`);
-		return lines.join("\n");
-	}
-	/**
-	* Build progress from workflow spans and step results (success path).
-	*/
-	_buildProgress(def, spans, stepResults) {
-		return def.steps.map((step, i) => {
-			const startSpan = spans.find((s) => s.name === "workflow.node.start" && s.attrs?.nodeId === step.id);
-			const finishSpan = spans.find((s) => s.name === "workflow.node.finish" && s.attrs?.nodeId === step.id);
-			let durationMs;
-			if (startSpan && finishSpan) durationMs = new Date(finishSpan.at).getTime() - new Date(startSpan.at).getTime();
-			const hasResult = step.id in stepResults;
-			return {
-				step: i + 1,
-				totalSteps: def.steps.length,
-				stepName: step.id,
-				status: hasResult ? "complete" : "skipped",
-				durationMs
-			};
-		});
-	}
-	/**
-	* Build partial progress for the failure path.
-	*/
-	_buildPartialProgress(def, error) {
-		return def.steps.map((step, i) => ({
-			step: i + 1,
-			totalSteps: def.steps.length,
-			stepName: step.id,
-			status: "failed",
-			error: i === 0 ? error : void 0
-		}));
-	}
-};
-//#endregion
-//#region src/server/macros/MacroConfigLoader.ts
-/**
-* MacroConfigLoader — Load user-defined macros from JSON config files.
-*
-* Discovers and validates JSON macro definitions from a directory
-* (typically `macros/` in the project root).
-*/
-/**
-* Load all valid macro definitions from JSON files in a directory.
-* Invalid files are logged as warnings and skipped.
-*/
-async function loadFromDirectory(dir) {
-	let files;
-	try {
-		files = await readdir(dir);
-	} catch {
-		return [];
-	}
-	const jsonFiles = files.filter((f) => extname(f) === ".json");
-	const macros = [];
-	for (const file of jsonFiles) {
-		const path = resolve(dir, file);
-		try {
-			const raw = JSON.parse(await readFile(path, "utf-8"));
-			if (validate(raw)) {
-				macros.push(toDefinition(raw));
-				logger.info(`[macros] Loaded user macro "${raw.id}" from ${file}`);
-			} else logger.warn(`[macros] Skipping ${file}: invalid macro schema`);
-		} catch (err) {
-			logger.warn(`[macros] Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-	return macros;
-}
-/**
-* Type guard — validates that raw JSON matches the expected macro schema.
-*/
-function validate(raw) {
-	if (!raw || typeof raw !== "object") return false;
-	const obj = raw;
-	if (typeof obj.id !== "string" || !obj.id) return false;
-	if (typeof obj.displayName !== "string" || !obj.displayName) return false;
-	if (!Array.isArray(obj.steps) || obj.steps.length === 0) return false;
-	for (const step of obj.steps) {
-		if (!step || typeof step !== "object") return false;
-		const s = step;
-		if (typeof s.id !== "string" || !s.id) return false;
-		if (typeof s.toolName !== "string" || !s.toolName) return false;
-	}
-	return true;
-}
-/**
-* Convert validated JSON to a MacroDefinition.
-*/
-function toDefinition(json) {
-	return {
-		id: json.id,
-		displayName: json.displayName,
-		description: json.description ?? "",
-		tags: json.tags ?? [],
-		timeoutMs: json.timeoutMs,
-		steps: json.steps.map((s) => ({
-			id: s.id,
-			toolName: s.toolName,
-			input: s.input,
-			inputFrom: s.inputFrom,
-			timeoutMs: s.timeoutMs,
-			optional: s.optional
-		}))
-	};
-}
-const MacroConfigLoader = {
-	loadFromDirectory,
-	validate
-};
-const BUILTIN_MACROS = [{
-	id: "deobfuscate_ast_flow",
-	displayName: "Deobfuscate AST Flow",
-	description: "Chain: deobfuscate → advanced deobfuscation → extract function tree",
-	tags: [
-		"analysis",
-		"deobfuscation",
-		"ast"
-	],
-	timeoutMs: MACRO_BUILTIN_TIMEOUT_MS,
-	steps: [
-		{
-			id: "deobfuscate",
-			toolName: "deobfuscate",
-			input: {}
-		},
-		{
-			id: "advanced_deobfuscate",
-			toolName: "deobfuscate",
-			input: { engine: "webcrack" },
-			inputFrom: { code: "deobfuscate.code" },
-			optional: true
-		},
-		{
-			id: "extract_functions",
-			toolName: "extract_function_tree",
-			inputFrom: { code: "deobfuscate.code" }
-		}
-	]
-}, {
-	id: "unpacker_flow",
-	displayName: "Unpacker Flow",
-	description: "Detect packer type → extract inner code → deobfuscate → beautify output",
-	tags: [
-		"analysis",
-		"unpacking",
-		"deobfuscation"
-	],
-	timeoutMs: 9e4,
-	steps: [
-		{
-			id: "detect_and_unpack",
-			toolName: "deobfuscate",
-			input: { unpack: true }
-		},
-		{
-			id: "deep_deobfuscate",
-			toolName: "deobfuscate",
-			input: { engine: "webcrack" },
-			inputFrom: { code: "detect_and_unpack.code" },
-			optional: true
-		},
-		{
-			id: "beautify",
-			toolName: "ast_transform_beautify",
-			inputFrom: { code: "detect_and_unpack.code" }
-		}
-	]
-}];
-//#endregion
-//#region src/server/domains/macro/handlers.ts
-/**
-* MacroToolHandlers — Handles macro domain MCP tool calls.
-*
-* Built-in macros are simple MacroDefinition data objects (step lists).
-* Complex workflow-based macros (DAG, BranchNode) should be registered
-* as extension workflows via the ExtensionManager.
-*/
-var MacroToolHandlers = class {
-	runner;
-	macros = null;
-	constructor(ctx) {
-		this.runner = new MacroRunner(ctx);
-	}
-	/**
-	* Lazily load all macros (built-in + user-defined).
-	* User-defined macros with the same ID override built-in ones.
-	*/
-	async ensureMacrosLoaded() {
-		if (this.macros) return this.macros;
-		this.macros = /* @__PURE__ */ new Map();
-		for (const m of BUILTIN_MACROS) this.macros.set(m.id, m);
-		try {
-			const userMacros = await MacroConfigLoader.loadFromDirectory(resolve(getProjectRoot(), "macros"));
-			for (const m of userMacros) this.macros.set(m.id, m);
-		} catch {}
-		return this.macros;
-	}
-	async handleRunMacro(args) {
-		const macroId = args.macroId;
-		const inputOverrides = args.inputOverrides;
-		if (!macroId || typeof macroId !== "string") return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				ok: false,
-				error: "macroId parameter is required"
-			})
-		}] };
-		const macros = await this.ensureMacrosLoaded();
-		const def = macros.get(macroId);
-		if (!def) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				ok: false,
-				error: `Macro "${macroId}" not found`,
-				available: Array.from(macros.keys())
-			})
-		}] };
-		const result = await this.runner.execute(def, inputOverrides);
-		return { content: [{
-			type: "text",
-			text: this.runner.formatProgressReport(result)
-		}] };
-	}
-	async handleListMacros() {
-		const macros = await this.ensureMacrosLoaded();
-		const list = Array.from(macros.values()).map((m) => ({
-			id: m.id,
-			displayName: m.displayName,
-			description: m.description,
-			tags: m.tags,
-			stepCount: m.steps.length
-		}));
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				macros: list,
-				count: list.length
-			})
-		}] };
-	}
-};
-//#endregion
-export { MacroToolHandlers };

package/dist/handlers-tB9Mp9ZK.mjs

@@ -1,84 +0,0 @@
-import { n as asJsonResponse, r as asTextResponse } from "./response-BQVP-xUn.mjs";
-//#region src/server/domains/evidence/handlers.ts
-/**
-* Evidence domain handlers — delegates to ReverseEvidenceGraph.
-*/
-var EvidenceHandlers = class {
-	constructor(graph) {
-		this.graph = graph;
-	}
-	serializeNodes(nodes) {
-		return nodes.map((node) => ({
-			id: node.id,
-			type: node.type,
-			label: node.label,
-			metadata: node.metadata
-		}));
-	}
-	handleQueryDispatch(args) {
-		switch (args["by"]) {
-			case "function": return this.handleQueryFunction(args);
-			case "script": return this.handleQueryScript(args);
-			default: return this.handleQueryUrl(args);
-		}
-	}
-	handleExportDispatch(args) {
-		if (args["format"] === "markdown") return this.handleExportMarkdown();
-		return this.handleExportJson();
-	}
-	handleQueryUrl(args) {
-		const url = args.url;
-		const nodes = this.graph.queryByUrl(url);
-		return asJsonResponse({
-			query: {
-				type: "url",
-				value: url
-			},
-			resultCount: nodes.length,
-			nodes: this.serializeNodes(nodes)
-		});
-	}
-	handleQueryFunction(args) {
-		const name = args.name;
-		const nodes = this.graph.queryByFunction(name);
-		return asJsonResponse({
-			query: {
-				type: "function",
-				value: name
-			},
-			resultCount: nodes.length,
-			nodes: this.serializeNodes(nodes)
-		});
-	}
-	handleQueryScript(args) {
-		const scriptId = args.scriptId;
-		const nodes = this.graph.queryByScriptId(scriptId);
-		return asJsonResponse({
-			query: {
-				type: "scriptId",
-				value: scriptId
-			},
-			resultCount: nodes.length,
-			nodes: this.serializeNodes(nodes)
-		});
-	}
-	handleExportJson() {
-		return asJsonResponse(this.graph.exportJson());
-	}
-	handleExportMarkdown() {
-		return asTextResponse(this.graph.exportMarkdown());
-	}
-	handleChain(args) {
-		const nodeId = args.nodeId;
-		const direction = args.direction ?? "forward";
-		const chain = this.graph.getEvidenceChain(nodeId, direction);
-		return asJsonResponse({
-			startNode: nodeId,
-			direction,
-			chainLength: chain.length,
-			nodes: this.serializeNodes(chain)
-		});
-	}
-};
-//#endregion
-export { EvidenceHandlers };