@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/handlers-U6L4xhuF.mjs

@@ -0,0 +1,585 @@
+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

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