@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/ToolRegistry-B9krbTtI.mjs

@@ -0,0 +1,180 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { J as EXTERNAL_TOOL_PROBE_CACHE_TTL_MS } from "./constants-CDZLOoVv.mjs";
+import { t as probeCommand } from "./ToolProbe-DbCFGyrg.mjs";
+//#region src/modules/external/ToolRegistry.ts
+/**
+* External tool registry.
+* Maintains a whitelist of allowed external tools with their specifications.
+* Only registered tools can be invoked through ExternalToolRunner.
+*/
+const DEFAULT_SPECS = [
+	{
+		name: "wabt.wasm2wat",
+		command: "wasm2wat",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "wabt.wasm-objdump",
+		command: "wasm-objdump",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "wabt.wasm-decompile",
+		command: "wasm-decompile",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "wabt.wasm2c",
+		command: "wasm2c",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "binaryen.wasm-opt",
+		command: "wasm-opt",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "runtime.wasmtime",
+		command: "wasmtime",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "runtime.wasmer",
+		command: "wasmer",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "miniapp.unpacker",
+		command: "unveilr",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "platform.jadx",
+		command: "jadx",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "analysis.ast-grep",
+		command: "ast-grep",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "analysis.wakaru",
+		command: "wakaru",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "analysis.restringer",
+		command: "restringer",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "analysis.z3",
+		command: "z3",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "syscall.strace",
+		command: "strace",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	},
+	{
+		name: "syscall.bpftrace",
+		command: "bpftrace",
+		versionArgs: ["--version"],
+		required: false,
+		envAllowlist: []
+	}
+];
+var ToolRegistry = class {
+	specs = /* @__PURE__ */ new Map();
+	probeCache = /* @__PURE__ */ new Map();
+	probeCacheExpiry = 0;
+	PROBE_CACHE_TTL = EXTERNAL_TOOL_PROBE_CACHE_TTL_MS;
+	constructor(additionalSpecs) {
+		for (const spec of DEFAULT_SPECS) this.specs.set(spec.name, spec);
+		if (additionalSpecs) for (const spec of additionalSpecs) this.specs.set(spec.name, spec);
+	}
+	/**
+	* Get the spec for a tool. Throws if not registered.
+	*/
+	getSpec(name) {
+		const spec = this.specs.get(name);
+		if (!spec) throw new Error(`Tool '${name}' is not registered in the allowlist`);
+		return spec;
+	}
+	/**
+	* Check if a tool name is registered.
+	*/
+	isRegistered(name) {
+		return this.specs.has(name);
+	}
+	/**
+	* Get all registered tool names.
+	*/
+	getRegisteredTools() {
+		return Array.from(this.specs.keys());
+	}
+	/**
+	* Probe all registered tools for availability. Results are cached.
+	*/
+	async probeAll(force = false) {
+		const now = Date.now();
+		if (!force && this.probeCache.size > 0 && now < this.probeCacheExpiry) return Object.fromEntries(this.probeCache);
+		const results = {};
+		const promises = [];
+		for (const [name, spec] of this.specs) promises.push(probeCommand(spec.command, spec.versionArgs).then((result) => {
+			results[name] = result;
+			this.probeCache.set(name, result);
+		}));
+		await Promise.all(promises);
+		this.probeCacheExpiry = now + this.PROBE_CACHE_TTL;
+		const available = Object.values(results).filter((r) => r.available).length;
+		logger.info(`[ToolRegistry] Probed ${this.specs.size} tools: ${available} available`);
+		return results;
+	}
+	/**
+	* Get cached probe result for a specific tool.
+	*/
+	getCachedProbe(name) {
+		return this.probeCache.get(name);
+	}
+	/**
+	* Register a new tool spec at runtime.
+	*/
+	register(spec) {
+		this.specs.set(spec.name, spec);
+		this.probeCache.delete(spec.name);
+		logger.debug(`[ToolRegistry] Registered tool: ${spec.name} -> ${spec.command}`);
+	}
+};
+//#endregion
+export { ToolRegistry as t };

package/dist/ToolRouter.policy-BGDAGyeH.mjs

@@ -0,0 +1,344 @@
+import { f as getAllManifests, r as getToolDomain, t as allTools } from "./ToolCatalog-5OJdMiF0.mjs";
+//#region src/server/ToolRouter.intent.ts
+const BROWSER_OR_NETWORK_TASK_PATTERN = /(browser|page|navigate|click|type|screenshot|scrape|network|request|response|api|traffic|hook|capture|intercept|monitor|浏览器|页面|导航|点击|输入|截图|爬取|网络|请求|响应|接口|流量|抓包|拦截|监控)/i;
+const MAINTENANCE_TASK_PATTERN = /(token budget|cache|artifact|extension|plugin|reload|doctor|cleanup|memory|profile|tool list|令牌预算|缓存|工件|扩展|插件|重载|环境诊断|清理|内存|配置)/i;
+const STATELESS_COMPUTE_TASK_PATTERN = /(stateless|deterministic|pure compute|offline|decode|encode|hex|base64|protobuf|msgpack|checksum|hash|payload|frame|packet|bytes?|bytecode|pcap|protocol|state machine|field inference|ast transform|crypto harness|无状态|确定性|纯算|离线|解码|编码|十六进制|校验和|载荷|字节|协议|报文|帧|字段推断|状态机|构包)/i;
+let cachedWorkflowRules = null;
+const intentCache = /* @__PURE__ */ new Map();
+const INTENT_CACHE_MAX = 64;
+/**
+* Aggregate workflow rules declared by domain manifests.
+* All routing metadata is now declared in each domain's manifest.ts,
+* following the open-closed principle (no hardcoded rules here).
+*
+* Cached lazily — manifests are immutable at runtime.
+*/
+function getEffectiveWorkflowRules() {
+	if (cachedWorkflowRules) return cachedWorkflowRules;
+	const rules = [];
+	for (const m of getAllManifests()) if (m.workflowRule) rules.push({
+		patterns: [...m.workflowRule.patterns],
+		domain: m.domain,
+		priority: m.workflowRule.priority,
+		tools: [...m.workflowRule.tools],
+		hint: m.workflowRule.hint
+	});
+	cachedWorkflowRules = [...rules].toSorted((a, b) => b.priority - a.priority);
+	intentCache.clear();
+	return cachedWorkflowRules;
+}
+function detectWorkflowIntent(query) {
+	const cached = intentCache.get(query);
+	if (cached !== void 0) return cached;
+	const matches = [];
+	for (const rule of getEffectiveWorkflowRules()) for (const pattern of rule.patterns) if (pattern.test(query)) {
+		matches.push(rule);
+		break;
+	}
+	const result = matches.length === 0 ? null : matches.toSorted((a, b) => b.priority - a.priority)[0];
+	if (intentCache.size >= INTENT_CACHE_MAX) {
+		const firstKey = intentCache.keys().next().value;
+		if (firstKey !== void 0) intentCache.delete(firstKey);
+	}
+	intentCache.set(query, result);
+	return result;
+}
+function matchWorkflowRoute(query, ctx) {
+	let bestMatch = null;
+	for (const [workflowId, runtimeRecord] of ctx.extensionWorkflowRuntimeById.entries()) {
+		const route = runtimeRecord.route ?? runtimeRecord.workflow.route;
+		if (!route) continue;
+		const descriptor = ctx.extensionWorkflowsById.get(workflowId);
+		const name = descriptor?.displayName ?? runtimeRecord.workflow.displayName;
+		const description = descriptor?.description ?? runtimeRecord.workflow.description ?? "Workflow route";
+		for (const pattern of route.triggerPatterns) {
+			if (!pattern.test(query)) continue;
+			const confidence = route.priority / 100;
+			if (!bestMatch || confidence > bestMatch.confidence) bestMatch = {
+				workflow: {
+					id: workflowId,
+					name,
+					description,
+					route
+				},
+				confidence,
+				matchedPattern: pattern.source
+			};
+			break;
+		}
+	}
+	return bestMatch;
+}
+function isBrowserOrNetworkTask(task, workflow) {
+	if (workflow?.domain !== "browser" && workflow?.domain !== "network" && isStatelessComputeTask(task)) return false;
+	return workflow?.domain === "browser" || workflow?.domain === "network" || BROWSER_OR_NETWORK_TASK_PATTERN.test(task);
+}
+function isMaintenanceTask(task) {
+	return MAINTENANCE_TASK_PATTERN.test(task);
+}
+function isStatelessComputeTask(task) {
+	return STATELESS_COMPUTE_TASK_PATTERN.test(task);
+}
+//#endregion
+//#region src/server/MCPServer.search.validation.ts
+/**
+* Input validation and tool-name normalization utilities for search meta-tool handlers.
+*/
+function normalizeToolName(name) {
+	const trimmed = name.trim();
+	if (!trimmed.startsWith("mcp__")) return trimmed;
+	const parts = trimmed.split("__");
+	if (parts.length < 3) return trimmed;
+	return parts.slice(2).join("__");
+}
+function validateToolNameArray(args) {
+	const raw = args.names;
+	if (!Array.isArray(raw)) return {
+		names: [],
+		error: "names must be an array"
+	};
+	const names = [];
+	for (const item of raw) {
+		if (typeof item !== "string" || item.trim().length === 0) return {
+			names: [],
+			error: "invalid tool name: expected non-empty string"
+		};
+		names.push(normalizeToolName(item));
+	}
+	return { names };
+}
+//#endregion
+//#region src/server/ToolRouter.probe.ts
+let allToolsByNameCache = null;
+function getAllToolsByName() {
+	if (!allToolsByNameCache) allToolsByNameCache = new Map(allTools.map((t) => [t.name, t]));
+	return allToolsByNameCache;
+}
+function getToolInputSchema(toolName, ctx) {
+	const canonicalName = normalizeToolName(toolName);
+	const builtInTool = getAllToolsByName().get(canonicalName);
+	if (builtInTool) return builtInTool.inputSchema;
+	const extTool = ctx.extensionToolsByName.get(canonicalName);
+	if (extTool) return extTool.tool.inputSchema;
+	const metaTool = ctx.metaToolsByName.get(canonicalName);
+	if (metaTool) return metaTool.inputSchema;
+}
+function getToolDescription(toolName, ctx) {
+	const canonicalName = normalizeToolName(toolName);
+	const builtInTool = getAllToolsByName().get(canonicalName);
+	if (builtInTool?.description) return builtInTool.description.split("\n")[0] || "No description available";
+	const extTool = ctx.extensionToolsByName.get(canonicalName);
+	if (extTool?.tool?.description) return extTool.tool.description.split("\n")[0] || "No description available";
+	const metaTool = ctx.metaToolsByName.get(canonicalName);
+	if (metaTool?.description) return metaTool.description.split("\n")[0] || "No description available";
+	return "No description available";
+}
+function isToolActive(toolName, ctx) {
+	const canonicalName = normalizeToolName(toolName);
+	return new Set([...ctx.selectedTools.map((tool) => tool.name), ...ctx.activatedToolNames]).has(canonicalName);
+}
+function getAvailableToolNames(ctx) {
+	return new Set([...allTools.map((tool) => tool.name), ...ctx.extensionToolsByName.keys()]);
+}
+function getToolDomainFromContext(toolName, ctx) {
+	return getToolDomain(toolName) ?? ctx.extensionToolsByName.get(toolName)?.domain ?? null;
+}
+async function probeActivePage(ctx) {
+	if (!ctx.pageController || typeof ctx.pageController.getPage !== "function") return false;
+	try {
+		return Boolean(await ctx.pageController.getPage());
+	} catch {
+		return false;
+	}
+}
+function probeNetworkEnabled(ctx) {
+	if (!ctx.consoleMonitor) return false;
+	try {
+		if (typeof ctx.consoleMonitor.getNetworkStatus === "function") return Boolean(ctx.consoleMonitor.getNetworkStatus().enabled);
+		if (typeof ctx.consoleMonitor.isNetworkEnabled === "function") return Boolean(ctx.consoleMonitor.isNetworkEnabled());
+	} catch {}
+	return false;
+}
+function probeCapturedRequests(ctx) {
+	if (!ctx.consoleMonitor || typeof ctx.consoleMonitor.getNetworkRequests !== "function") return 0;
+	try {
+		const requests = ctx.consoleMonitor.getNetworkRequests({ limit: 1 });
+		return Array.isArray(requests) ? requests.length : 0;
+	} catch {
+		try {
+			const requests = ctx.consoleMonitor.getNetworkRequests();
+			return Array.isArray(requests) ? requests.length : 0;
+		} catch {
+			return 0;
+		}
+	}
+}
+async function getRoutingState(ctx) {
+	return {
+		hasActivePage: await probeActivePage(ctx),
+		networkEnabled: probeNetworkEnabled(ctx),
+		capturedRequestCount: probeCapturedRequests(ctx)
+	};
+}
+//#endregion
+//#region src/server/ToolRouter.policy.ts
+function buildStatelessComputeSequence(task, availableToolNames) {
+	if (!isStatelessComputeTask(task)) return [];
+	const candidates = [];
+	const pushIfAvailable = (name, description) => {
+		if (availableToolNames.has(name) && !candidates.some((item) => item.name === name)) candidates.push({
+			name,
+			description
+		});
+	};
+	pushIfAvailable("binary_detect_format", "Detect the payload encoding or container before decoding");
+	pushIfAvailable("binary_decode", "Decode the payload into deterministic offline bytes or structured output");
+	pushIfAvailable("proto_auto_detect", "Infer a likely protocol layout from repeated payload samples");
+	pushIfAvailable("proto_infer_fields", "Derive stable field boundaries and candidate semantics");
+	pushIfAvailable("proto_infer_state_machine", "Infer request/response state transitions from repeated samples");
+	pushIfAvailable("crypto_test_harness", "Validate extracted signing or crypto logic with deterministic test vectors");
+	pushIfAvailable("crypto_compare", "Compare competing crypto implementations against the same vectors");
+	pushIfAvailable("network_get_requests", "Collect request or response samples only if payload bytes still need to be extracted");
+	return candidates;
+}
+/**
+* Build a real runtime check function from the prerequisite condition string.
+* Returns true when the prerequisite IS satisfied, false when it is not.
+*/
+function buildPrerequisiteCheck(condition) {
+	if (condition.includes("Browser must be launched")) return (state) => state.hasActivePage;
+	if (condition.includes("Network monitoring must be enabled")) return (state) => state.networkEnabled;
+	if (condition.includes("Debugger must be enabled")) return (state) => state.hasActivePage;
+	if (condition.includes("Debugger must be attached")) return (state) => state.hasActivePage;
+	if (condition.includes("Page must be navigated")) return (state) => state.hasActivePage;
+	if (condition.includes("WebSocket monitoring")) return (state) => state.hasActivePage;
+	return () => false;
+}
+let cachedPrerequisites = null;
+/**
+* Aggregate prerequisite declarations from domain manifests.
+* Cached lazily — manifests are immutable at runtime.
+*/
+function getEffectivePrerequisites() {
+	if (cachedPrerequisites) return cachedPrerequisites;
+	const merged = {};
+	for (const m of getAllManifests()) if (m.prerequisites) for (const [toolName, entries] of Object.entries(m.prerequisites)) merged[toolName] = entries.map((e) => ({
+		condition: e.condition,
+		check: buildPrerequisiteCheck(e.condition),
+		fix: e.fix
+	}));
+	cachedPrerequisites = merged;
+	return cachedPrerequisites;
+}
+function buildWorkflowToolSequence(workflow, state, availableToolNames) {
+	const sequence = [];
+	const pushIfAvailable = (toolName) => {
+		if (availableToolNames.has(toolName) && !sequence.includes(toolName)) sequence.push(toolName);
+	};
+	if ((workflow.domain === "browser" || workflow.domain === "network") && !state.hasActivePage) {
+		pushIfAvailable("browser_launch");
+		pushIfAvailable("browser_attach");
+	}
+	if (workflow.domain === "network") {
+		if (state.hasActivePage && !state.networkEnabled) pushIfAvailable("network_monitor");
+		if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0) pushIfAvailable("network_get_requests");
+	}
+	for (const toolName of workflow.tools) pushIfAvailable(toolName);
+	if (workflow.domain === "network" && state.hasActivePage && state.networkEnabled) pushIfAvailable("network_get_requests");
+	return sequence;
+}
+function buildPresetToolSequence(match, state, availableToolNames) {
+	const sequence = [];
+	const seen = /* @__PURE__ */ new Set();
+	const requiresBrowserSession = match.workflow.route.requiredDomains.includes("browser") || match.workflow.route.requiredDomains.includes("network");
+	const pushIfAvailable = (toolName, description) => {
+		if (!availableToolNames.has(toolName) || seen.has(toolName)) return;
+		seen.add(toolName);
+		sequence.push({
+			name: toolName,
+			description
+		});
+	};
+	if (!state.hasActivePage && requiresBrowserSession) {
+		pushIfAvailable("browser_launch", "Launch a browser session before executing the preset");
+		pushIfAvailable("browser_attach", "Attach preset tooling to the active browser session before capture begins");
+	}
+	for (const step of match.workflow.route.steps) pushIfAvailable(step.toolName, step.description);
+	return sequence;
+}
+function buildPresetRecommendations(match, state, ctx, availableToolNames) {
+	return buildPresetToolSequence(match, state, availableToolNames).map((plannedTool, index) => ({
+		name: plannedTool.name,
+		domain: getToolDomainFromContext(plannedTool.name, ctx),
+		shortDescription: plannedTool.description,
+		score: match.workflow.route.priority + match.confidence - index * .01,
+		isActive: isToolActive(plannedTool.name, ctx)
+	}));
+}
+function buildStatelessComputeRecommendations(task, ctx, availableToolNames) {
+	return buildStatelessComputeSequence(task, availableToolNames).map((plannedTool, index) => ({
+		name: plannedTool.name,
+		domain: getToolDomainFromContext(plannedTool.name, ctx),
+		shortDescription: plannedTool.description,
+		score: 90 - index * .01,
+		isActive: isToolActive(plannedTool.name, ctx)
+	}));
+}
+function buildWorkflowRouteRecommendation(match, ctx) {
+	return {
+		name: "run_extension_workflow",
+		domain: getToolDomainFromContext("run_extension_workflow", ctx),
+		shortDescription: `Execute routed workflow ${match.workflow.name} (${match.workflow.id}) via run_extension_workflow`,
+		score: match.workflow.route.priority + match.confidence,
+		isActive: isToolActive("run_extension_workflow", ctx)
+	};
+}
+function buildRouteMatchMetadata(match, ctx) {
+	return {
+		kind: match.workflow.route.kind,
+		id: match.workflow.id,
+		name: match.workflow.name,
+		description: match.workflow.description,
+		confidence: match.confidence,
+		matchedPattern: match.matchedPattern,
+		requiredDomains: [...match.workflow.route.requiredDomains],
+		steps: match.workflow.route.steps.map((step) => ({
+			id: step.id,
+			toolName: step.toolName,
+			domain: getToolDomain(step.toolName) ?? ctx.extensionToolsByName.get(step.toolName)?.domain ?? null,
+			description: step.description,
+			prerequisites: [...step.prerequisites],
+			parallel: step.parallel,
+			isActive: isToolActive(step.toolName, ctx)
+		}))
+	};
+}
+function rerankResultsForContext(results, task, workflow, state) {
+	const browserOrNetworkTask = isBrowserOrNetworkTask(task, workflow);
+	const maintenanceTask = isMaintenanceTask(task);
+	const statelessComputeTask = isStatelessComputeTask(task);
+	const reranked = results.map((result) => {
+		let score = result.score;
+		if (browserOrNetworkTask && !maintenanceTask && result.domain === "maintenance") score *= .1;
+		if (statelessComputeTask) {
+			if (result.domain === "browser" || result.domain === "network" || result.domain === "debugger" || result.domain === "hooks" || result.domain === "maintenance") score *= .35;
+			if (result.domain === "core" || result.domain === "streaming" || result.domain === "workflow") score *= .2;
+			if (result.domain === "encoding" || result.domain === "transform" || result.domain === "protocol-analysis" || result.domain === "sourcemap" || result.domain === "core") score *= 1.6;
+			if (result.name === "binary_detect_format" || result.name === "binary_decode" || result.name === "crypto_test_harness" || result.name === "ast_transform_apply" || result.name === "proto_auto_detect" || result.name === "proto_infer_fields" || result.name === "proto_infer_state_machine" || result.name === "proto_fingerprint") score *= 1.25;
+		}
+		if (browserOrNetworkTask) {
+			if (!state.hasActivePage && result.name === "browser_launch") score *= 1.4;
+			if (!state.hasActivePage && result.name === "browser_attach") score *= 1.2;
+			if (state.hasActivePage && !state.networkEnabled && result.name === "network_monitor") score *= 1.35;
+			if (state.hasActivePage && state.networkEnabled && state.capturedRequestCount > 0 && result.name === "network_get_requests") score *= 1.5;
+		}
+		return {
+			...result,
+			score
+		};
+	});
+	reranked.sort((a, b) => b.score - a.score);
+	return reranked;
+}
+//#endregion
+export { isBrowserOrNetworkTask as _, buildWorkflowToolSequence as a, matchWorkflowRoute as b, getAvailableToolNames as c, getToolDomainFromContext as d, getToolInputSchema as f, detectWorkflowIntent as g, validateToolNameArray as h, buildWorkflowRouteRecommendation as i, getRoutingState as l, normalizeToolName as m, buildRouteMatchMetadata as n, getEffectivePrerequisites as o, isToolActive as p, buildStatelessComputeRecommendations as r, rerankResultsForContext as s, buildPresetRecommendations as t, getToolDescription as u, isMaintenanceTask as v, isStatelessComputeTask as y };