@regle/mcp-server 1.14.7-beta.1 → 1.14.7-beta.3

package/dist/regle-mcp-server.js

@@ -1,7 +1,378 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import "posthog-node";
+
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const path = __require("path");
+	const os = __require("os");
+	const crypto = __require("crypto");
+	const version$1 = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options$1) {
+		options$1 = options$1 || {};
+		const vaultPath = _vaultPath(options$1);
+		options$1.path = vaultPath;
+		const result = DotenvModule.configDotenv(options$1);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options$1).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version$1}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version$1}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version$1}] ${message}`);
+	}
+	function _dotenvKey(options$1) {
+		if (options$1 && options$1.DOTENV_KEY && options$1.DOTENV_KEY.length > 0) return options$1.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options$1) {
+		let possibleVaultPath = null;
+		if (options$1 && options$1.path && options$1.path.length > 0) if (Array.isArray(options$1.path)) {
+			for (const filepath of options$1.path) if (fs.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options$1.path.endsWith(".vault") ? options$1.path : `${options$1.path}.vault`;
+		else possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+		if (fs.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options$1) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options$1 && options$1.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options$1 && options$1.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options$1);
+		let processEnv = process.env;
+		if (options$1 && options$1.processEnv != null) processEnv = options$1.processEnv;
+		DotenvModule.populate(processEnv, parsed, options$1);
+		return { parsed };
+	}
+	function configDotenv(options$1) {
+		const dotenvPath = path.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options$1 && options$1.processEnv != null) processEnv = options$1.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options$1 && options$1.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options$1 && options$1.quiet);
+		if (options$1 && options$1.encoding) encoding = options$1.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options$1 && options$1.path) if (!Array.isArray(options$1.path)) optionPaths = [_resolveHome(options$1.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options$1.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path$1 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs.readFileSync(path$1, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options$1);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path$1} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options$1);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options$1) {
+		if (_dotenvKey(options$1).length === 0) return DotenvModule.configDotenv(options$1);
+		const vaultPath = _vaultPath(options$1);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options$1);
+		}
+		return DotenvModule._configVault(options$1);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options$1 = {}) {
+		const debug = Boolean(options$1 && options$1.debug);
+		const override = Boolean(options$1 && options$1.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+var require_env_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const options = {};
+	if (process.env.DOTENV_CONFIG_ENCODING != null) options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	if (process.env.DOTENV_CONFIG_PATH != null) options.path = process.env.DOTENV_CONFIG_PATH;
+	if (process.env.DOTENV_CONFIG_QUIET != null) options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	if (process.env.DOTENV_CONFIG_DEBUG != null) options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	module.exports = options;
+}));
+
+var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+	module.exports = function optionMatcher(args) {
+		const options$1 = args.reduce(function(acc, cur) {
+			const matches = cur.match(re);
+			if (matches) acc[matches[1]] = matches[2];
+			return acc;
+		}, {});
+		if (!("quiet" in options$1)) options$1.quiet = "true";
+		return options$1;
+	};
+}));
+
+(function() {
+	require_main().config(Object.assign({}, require_env_options(), require_cli_options()(process.argv)));
+})();
 
 var docs_data_default = {
 	docs: [
@@ -1663,7 +2034,15 @@ function searchApi(query) {
 	return results;
 }
 
-var version = "1.14.7-beta.1";
+var version = "1.14.7-beta.3";
+
+function trackServerConnected(params) {}
+function trackToolCall(params) {}
+function trackSearchQuery(params) {}
+function trackDocAccessed(params) {}
+function trackRuleLookup(params) {}
+function trackHelperLookup(params) {}
+async function shutdown() {}
 
 function jsonResponse(data$1) {
 	return { content: [{
@@ -1687,7 +2066,38 @@ const server = new McpServer({
 	title: "Regle MCP Server",
 	websiteUrl: "https://reglejs.dev"
 });
-server.registerTool("regle-list-documentation", {
+function getClientInfo() {
+	const clientInfo = server.server.getClientVersion();
+	return {
+		clientName: clientInfo?.name,
+		clientVersion: clientInfo?.version
+	};
+}
+function registerTrackedTool(name, config$1, handler) {
+	server.registerTool(name, config$1, async (args) => {
+		const clientInfo = getClientInfo();
+		try {
+			const result = await handler(args, clientInfo);
+			const isError = "isError" in result && result.isError === true;
+			/* @__PURE__ */ trackToolCall({
+				toolName: name,
+				success: !isError,
+				...clientInfo,
+				...isError && { errorMessage: JSON.stringify(result.content) }
+			});
+			return result;
+		} catch (error) {
+			/* @__PURE__ */ trackToolCall({
+				toolName: name,
+				success: false,
+				...clientInfo,
+				errorMessage: error instanceof Error ? error.message : String(error)
+			});
+			return Promise.reject(error);
+		}
+	});
+}
+registerTrackedTool("regle-list-documentation", {
 	title: "List all available Regle documentation pages",
 	inputSchema: z.object({ category: z.string().optional().describe("Filter by category (e.g., \"rules\", \"core-concepts\", \"introduction\")") })
 }, async ({ category }) => {
@@ -1702,15 +2112,20 @@ server.registerTool("regle-list-documentation", {
 		}))
 	});
 });
-server.registerTool("regle-get-documentation", {
+registerTrackedTool("regle-get-documentation", {
 	title: "Get the full content of a specific Regle documentation page",
 	inputSchema: z.object({ id: z.string().describe("The documentation page ID (e.g., \"core-concepts-rules-built-in-rules\")") })
-}, async ({ id }) => {
+}, async ({ id }, clientInfo) => {
 	const doc = getDocById(id);
 	if (!doc) return errorResponse("Documentation page not found", {
 		requestedId: id,
 		availableIds: docs.map((d) => d.id)
 	});
+	/* @__PURE__ */ trackDocAccessed({
+		...clientInfo,
+		docId: doc.id,
+		docCategory: doc.category
+	});
 	return jsonResponse({
 		id: doc.id,
 		title: doc.title,
@@ -1719,12 +2134,17 @@ server.registerTool("regle-get-documentation", {
 		content: doc.content
 	});
 });
-server.registerTool("regle-get-usage-guide", {
+registerTrackedTool("regle-get-usage-guide", {
 	title: "Get a comprehensive guide on how to use the useRegle composable",
 	inputSchema: z.object({})
-}, async () => {
+}, async (_args, clientInfo) => {
 	const doc = getDocById("core-concepts-index");
 	if (!doc) return errorResponse("useRegle guide not found");
+	/* @__PURE__ */ trackDocAccessed({
+		...clientInfo,
+		docId: doc.id,
+		docCategory: doc.category
+	});
 	return jsonResponse({
 		id: doc.id,
 		title: doc.title,
@@ -1732,12 +2152,17 @@ server.registerTool("regle-get-usage-guide", {
 		content: doc.content
 	});
 });
-server.registerTool("regle-get-vuelidate-migration-guide", {
+registerTrackedTool("regle-get-vuelidate-migration-guide", {
 	title: "Get a guide on how to migrate from Vuelidate to Regle",
 	inputSchema: z.object({})
-}, async () => {
+}, async (_args, clientInfo) => {
 	const doc = getDocById("introduction-migrate-from-vuelidate");
 	if (!doc) return errorResponse("Vuelidate migration guide not found");
+	/* @__PURE__ */ trackDocAccessed({
+		...clientInfo,
+		docId: doc.id,
+		docCategory: doc.category
+	});
 	return jsonResponse({
 		id: doc.id,
 		title: doc.title,
@@ -1746,14 +2171,20 @@ server.registerTool("regle-get-vuelidate-migration-guide", {
 	});
 });
 const categories = getCategories();
-server.registerTool("regle-search-documentation", {
+registerTrackedTool("regle-search-documentation", {
 	title: "Search Regle documentation for specific topics, rules, or concepts",
 	inputSchema: z.object({
 		query: z.string().describe("Search query (e.g., \"required\", \"async validation\", \"useRegle\")"),
 		limit: z.number().optional().default(5).describe("Maximum number of results to return")
 	})
-}, async ({ query, limit }) => {
+}, async ({ query, limit }, clientInfo) => {
 	const results = searchDocs(query).slice(0, limit);
+	/* @__PURE__ */ trackSearchQuery({
+		...clientInfo,
+		query,
+		resultCount: results.length,
+		toolName: "regle-search-documentation"
+	});
 	if (results.length === 0) return jsonResponse({
 		query,
 		resultCount: 0,
@@ -1772,10 +2203,10 @@ server.registerTool("regle-search-documentation", {
 		results: formattedResults
 	});
 });
-server.registerTool("regle-list-rules", {
+registerTrackedTool("regle-list-rules", {
 	title: "Get a quick reference of all built-in validation rules in Regle",
 	inputSchema: z.object({})
-}, async () => {
+}, async (_args, _clientInfo) => {
 	const rules = getRulesFromDocs();
 	if (rules.length === 0) return errorResponse("Built-in rules documentation not found");
 	return jsonResponse({
@@ -1799,11 +2230,16 @@ const { r$ } = useRegle(
 		fullDocId: "core-concepts-rules-built-in-rules"
 	});
 });
-server.registerTool("regle-get-rule-reference", {
+registerTrackedTool("regle-get-rule-reference", {
 	title: "Get details about a specific built-in validation rule",
 	inputSchema: z.object({ name: z.string().describe("The rule name (e.g., \"required\", \"email\", \"minLength\")") })
-}, async ({ name }) => {
+}, async ({ name }, clientInfo) => {
 	const rule = getApiByName(name);
+	/* @__PURE__ */ trackRuleLookup({
+		...clientInfo,
+		ruleName: name,
+		found: !!rule
+	});
 	if (!rule) {
 		const allRules = getRulesFromDocs();
 		return errorResponse(`Rule "${name}" not found`, { availableRules: allRules.map((r) => r.name) });
@@ -1816,12 +2252,17 @@ server.registerTool("regle-get-rule-reference", {
 		fullDocId: "core-concepts-rules-built-in-rules"
 	});
 });
-server.registerTool("regle-list-validation-properties", {
+registerTrackedTool("regle-list-validation-properties", {
 	title: "Get documentation on all validation properties available on r$ and field objects",
 	inputSchema: z.object({})
-}, async () => {
+}, async (_args, clientInfo) => {
 	const doc = getDocById("core-concepts-validation-properties");
 	if (!doc) return errorResponse("Validation properties documentation not found");
+	/* @__PURE__ */ trackDocAccessed({
+		...clientInfo,
+		docId: doc.id,
+		docCategory: doc.category
+	});
 	return jsonResponse({
 		id: doc.id,
 		title: doc.title,
@@ -1829,10 +2270,10 @@ server.registerTool("regle-list-validation-properties", {
 		content: doc.content
 	});
 });
-server.registerTool("regle-list-helpers", {
+registerTrackedTool("regle-list-helpers", {
 	title: "Get a reference of all validation helper utilities available in Regle",
 	inputSchema: z.object({})
-}, async () => {
+}, async (_args, _clientInfo) => {
 	const helpers = getHelpersFromDocs();
 	if (helpers.length === 0) return errorResponse("Validation helpers documentation not found");
 	const guards = helpers.filter((h) => h.category === "guard");
@@ -1875,11 +2316,16 @@ const rule = createRule({
 		fullDocId: "core-concepts-rules-validations-helpers"
 	});
 });
-server.registerTool("regle-get-helper-reference", {
+registerTrackedTool("regle-get-helper-reference", {
 	title: "Get details about a specific validation helper utility",
 	inputSchema: z.object({ name: z.string().describe("The helper name (e.g., \"isFilled\", \"getSize\", \"toNumber\")") })
-}, async ({ name }) => {
+}, async ({ name }, clientInfo) => {
 	const helper = getApiByName(name);
+	/* @__PURE__ */ trackHelperLookup({
+		...clientInfo,
+		helperName: name,
+		found: !!helper
+	});
 	if (!helper) {
 		const allHelpers = getHelpersFromDocs();
 		return errorResponse(`Helper "${name}" not found`, { availableHelpers: allHelpers.map((h) => h.name) });
@@ -1894,14 +2340,14 @@ server.registerTool("regle-get-helper-reference", {
 	});
 });
 const apiPackages = getApiPackages();
-server.registerTool("regle-get-api-reference", {
+registerTrackedTool("regle-get-api-reference", {
 	title: "Get API reference for Regle packages with full metadata (parameters, return types, examples)",
 	inputSchema: z.object({
 		package: z.string().optional().describe("Package name (e.g., \"@regle/core\", \"@regle/rules\", \"@regle/schemas\", \"@regle/nuxt\")"),
 		name: z.string().optional().describe("Specific function/export name to look up (e.g., \"useRegle\", \"required\")"),
 		search: z.string().optional().describe("Search query to find exports by name or description")
 	})
-}, async ({ package: packageName, name, search }) => {
+}, async ({ package: packageName, name, search }, clientInfo) => {
 	if (name) {
 		const apiItem = getApiByName(name, packageName);
 		if (!apiItem) return errorResponse(`API export "${name}" not found`, { availablePackages: apiPackages });
@@ -1917,6 +2363,12 @@ server.registerTool("regle-get-api-reference", {
 	}
 	if (search) {
 		const results = searchApi(search);
+		/* @__PURE__ */ trackSearchQuery({
+			...clientInfo,
+			query: search,
+			resultCount: results.length,
+			toolName: "regle-get-api-reference"
+		});
 		return jsonResponse({
 			query: search,
 			resultCount: results.length,
@@ -1955,10 +2407,22 @@ server.registerTool("regle-get-api-reference", {
 async function main() {
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
+	const clientInfo = server.server.getClientVersion();
+	/* @__PURE__ */ trackServerConnected({
+		clientName: clientInfo?.name,
+		clientVersion: clientInfo?.version
+	});
 	console.error("Regle MCP Server running on stdio");
 }
-main().catch((error) => {
+async function gracefulShutdown() {
+	await /* @__PURE__ */ shutdown();
+	process.exit(0);
+}
+process.on("SIGINT", gracefulShutdown);
+process.on("SIGTERM", gracefulShutdown);
+main().catch(async (error) => {
 	console.error("Failed to start server:", error);
+	await /* @__PURE__ */ shutdown();
 	process.exit(1);
 });
 

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@regle/mcp-server",
-  "version": "1.14.7-beta.1",
+  "version": "1.14.7-beta.3",
   "description": "MCP Server for Regle",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.24.3",
+    "posthog-node": "5.17.4",
     "zod": "4.1.13"
   },
   "devDependencies": {
     "@types/node": "22.19.1",
     "tsdown": "0.16.8",
     "tsx": "4.21.0",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "dotenv": "17.2.3"
   },
   "type": "module",
   "exports": {