@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/ToolRegistry-BjaF4oNz.mjs

@@ -0,0 +1,131 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { q as EXTERNAL_TOOL_PROBE_CACHE_TTL_MS } from "./constants-B0OANIBL.mjs";
+import { t as probeCommand } from "./ToolProbe-oC7aPrkv.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: "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: []
+	}
+];
+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-BWV67ZK-.mjs

@@ -0,0 +1,304 @@
+import { f as getAllManifests, r as getToolDomain, t as allTools } from "./ToolCatalog-C0JGZoOm.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;
+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) {
+	return workflow?.domain === "browser" || workflow?.domain === "network" || BROWSER_OR_NETWORK_TASK_PATTERN.test(task);
+}
+function isMaintenanceTask(task) {
+	return MAINTENANCE_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 _allToolsByName = null;
+function getAllToolsByName() {
+	if (!_allToolsByName) _allToolsByName = new Map(allTools.map((t) => [t.name, t]));
+	return _allToolsByName;
+}
+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
+/**
+* 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 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 reranked = results.map((result) => {
+		let score = result.score;
+		if (browserOrNetworkTask && !maintenanceTask && result.domain === "maintenance") score *= .1;
+		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 { isMaintenanceTask as _, getEffectivePrerequisites as a, getRoutingState as c, getToolInputSchema as d, isToolActive as f, isBrowserOrNetworkTask as g, detectWorkflowIntent as h, buildWorkflowToolSequence as i, getToolDescription as l, validateToolNameArray as m, buildRouteMatchMetadata as n, rerankResultsForContext as o, normalizeToolName as p, buildWorkflowRouteRecommendation as r, getAvailableToolNames as s, buildPresetRecommendations as t, getToolDomainFromContext as u, matchWorkflowRoute as v };