mc8yp 2.0.0 → 2.0.1

package/README.md

@@ -234,6 +234,10 @@ The versions built are driven by [`openapi-versions.json`](openapi-versions.json
 
 Use the dedicated packaging command after `pnpm build` to create Docker-based Cumulocity release zips:
 
+The packaging step writes a temporary generated Dockerfile under `.c8y/`, copies the selected versioned server bundle into `/app/server/`, and installs production dependencies inside the Linux image with pnpm before copying them into the runtime stage. This avoids cross-platform native optional dependency issues when release artifacts are built on macOS but deployed as `linux/amd64` microservices.
+
+The deployed HTTP transport uses POST-only streamable HTTP (`GET /mcp` intentionally returns `405`) because some reverse proxies and microservice ingress layers do not keep the optional long-lived SSE notification channel stable enough for reliable MCP tool calls.
+
 ```sh
 pnpm package:microservices
 ```
@@ -251,7 +255,7 @@ The GitHub release workflow uses that packaging command when building tagged rel
 
 ### Prerequisites
 
-- Node.js ≥22.0.0
+- Node.js ≥24.0.0
 - pnpm
 
 ### Setup

package/dist/cli.mjs

@@ -10,7 +10,6 @@ import { defineTool } from "tmcp/tool";
 import * as v from "valibot";
 import { encode } from "@toon-format/toon";
 import { NodeRuntime, createNodeDriver, createNodeRuntimeDriverFactory } from "secure-exec";
-import "ufo";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { useContext } from "unctx";
@@ -41,7 +40,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
 //#region package.json
 var name = "mc8yp";
-var version = "2.0.0";
+var version = "2.0.1";
 var description = "Cumulocity IoT MCP Server - Model Context Protocol integration for IoT device management";
 //#endregion
 //#region \0virtual:core-openapi
@@ -85363,7 +85362,7 @@ function createPrompts(server) {
 	return [createCodeModeGuidePrompt(server)];
 }
 //#endregion
-//#region src/utils/restriction-core.ts
+//#region src/utils/restrictions.ts
 const HTTP_METHODS = [
 	"DELETE",
 	"GET",
@@ -85374,49 +85373,130 @@ const HTTP_METHODS = [
 	"PUT",
 	"TRACE"
 ];
-const HTTP_METHOD_SET$1 = new Set(HTTP_METHODS);
-function normalizeRestrictionMatchPath(value) {
-	let raw = value.trim();
-	if (!raw) return "/";
-	raw = raw.startsWith("/") ? raw : `/${raw}`;
-	raw = raw.replace(/\/{2,}/g, "/");
-	return raw.length > 1 && raw.endsWith("/") ? raw.slice(0, -1) : raw || "/";
-}
-function normalizeAndValidateRestrictionPath(rawPath) {
-	const segmentPattern = /^[A-Za-z0-9._~*-]+$/;
-	if (rawPath.includes("?") || rawPath.includes("#")) throw new Error(`Restriction pattern "${rawPath}" must not include query strings or fragments.`);
-	if (!rawPath.startsWith("/")) throw new Error("Restriction path pattern must start with \"/\".");
-	const pathPattern = normalizeRestrictionMatchPath(rawPath);
-	const segments = pathPattern === "/" ? [] : pathPattern.slice(1).split("/");
-	for (const segment of segments) {
-		if (segment === "." || segment === "..") throw new Error(`Restriction segment "${segment}" is not allowed.`);
-		if (segment === "**") continue;
-		if (segment.includes("**")) throw new Error(`Invalid restriction segment "${segment}". "**" must be its own path segment.`);
-		if (!segmentPattern.test(segment)) throw new Error(`Restriction segment "${segment}" contains unsupported characters.`);
-	}
-	return pathPattern;
-}
+const HTTP_METHOD_SET = new Set(HTTP_METHODS);
+const RESTRICTION_EXTENSION_KEY = "x-mc8yp-restrictions";
+const RESTRICTED_OPERATION_FLAG = "x-mc8yp-restricted";
+const RESTRICTED_OPERATION_MESSAGE = "x-mc8yp-restrictionMessage";
+const RESTRICTED_OPERATION_RULES = "x-mc8yp-restrictionRules";
+const RESTRICTED_OPERATION_TYPE = "x-mc8yp-restrictionType";
+const RESTRICTED_AGENT_NOTE = "x-mc8yp-agentNote";
 function parseRestrictionRule(input) {
-	const source = input.trim();
-	if (!source) throw new Error("Restriction value must not be empty.");
-	const sep = source.indexOf(":");
-	if (sep > 0 && !source.startsWith("/")) {
-		const rawMethod = source.slice(0, sep).trim().toUpperCase();
-		const rawPath = source.slice(sep + 1).trim();
-		if (!rawPath) throw new Error("Restriction path pattern must not be empty.");
-		if (rawMethod && rawMethod !== "*" && !HTTP_METHOD_SET$1.has(rawMethod)) throw new Error(`Unsupported restriction method "${source.slice(0, sep)}".`);
-		return {
-			method: !rawMethod || rawMethod === "*" ? "*" : rawMethod,
-			pathPattern: normalizeAndValidateRestrictionPath(rawPath),
+	const segmentPattern = /^[A-Za-z0-9._~*-]+$/;
+	const inputs = typeof input === "string" ? [input] : input;
+	const parsedRules = [];
+	const failedRules = [];
+	for (const source of inputs) {
+		if (!source) {
+			failedRules.push({
+				rule: source,
+				reason: "Restriction value must not be empty."
+			});
+			continue;
+		}
+		const sep = source.indexOf(":");
+		if (sep > 0 && !source.startsWith("/")) {
+			const rawMethod = source.slice(0, sep).toUpperCase();
+			const rawPath = source.slice(sep + 1);
+			if (!rawPath) {
+				failedRules.push({
+					rule: source,
+					reason: "Restriction path pattern must not be empty."
+				});
+				continue;
+			}
+			if (rawMethod && rawMethod !== "*" && !HTTP_METHOD_SET.has(rawMethod)) {
+				failedRules.push({
+					rule: source,
+					reason: `Unsupported restriction method "${source.slice(0, sep)}".`
+				});
+				continue;
+			}
+			if (rawPath.includes("?") || rawPath.includes("#")) {
+				failedRules.push({
+					rule: source,
+					reason: `Restriction pattern "${rawPath}" must not include query strings or fragments.`
+				});
+				continue;
+			}
+			if (!rawPath.startsWith("/")) {
+				failedRules.push({
+					rule: source,
+					reason: "Restriction path pattern must start with \"/\"."
+				});
+				continue;
+			}
+			const rawPathSegments = rawPath === "/" ? [] : rawPath.slice(1).split("/");
+			if (rawPathSegments.some((segment) => segment.length === 0)) {
+				failedRules.push({
+					rule: source,
+					reason: "Restriction path pattern must not contain empty segments."
+				});
+				continue;
+			}
+			const invalidRawPathSegment = rawPathSegments.find((segment) => {
+				if (segment === "**") return false;
+				return segment.includes("**") || segment === "." || segment === ".." || !segmentPattern.test(segment);
+			});
+			if (invalidRawPathSegment) {
+				failedRules.push({
+					rule: source,
+					reason: invalidRawPathSegment === "." || invalidRawPathSegment === ".." ? `Restriction segment "${invalidRawPathSegment}" is not allowed.` : invalidRawPathSegment.includes("**") ? `Invalid restriction segment "${invalidRawPathSegment}". "**" must be its own path segment.` : `Restriction segment "${invalidRawPathSegment}" contains unsupported characters.`
+				});
+				continue;
+			}
+			parsedRules.push({
+				method: !rawMethod || rawMethod === "*" ? "*" : rawMethod,
+				pathPattern: rawPath,
+				source
+			});
+			continue;
+		}
+		if (source.includes("?") || source.includes("#")) {
+			failedRules.push({
+				rule: source,
+				reason: `Restriction pattern "${source}" must not include query strings or fragments.`
+			});
+			continue;
+		}
+		if (!source.startsWith("/")) {
+			failedRules.push({
+				rule: source,
+				reason: "Restriction path pattern must start with \"/\"."
+			});
+			continue;
+		}
+		const sourceSegments = source === "/" ? [] : source.slice(1).split("/");
+		if (sourceSegments.some((segment) => segment.length === 0)) {
+			failedRules.push({
+				rule: source,
+				reason: "Restriction path pattern must not contain empty segments."
+			});
+			continue;
+		}
+		const invalidSourceSegment = sourceSegments.find((segment) => {
+			if (segment === "**") return false;
+			return segment.includes("**") || segment === "." || segment === ".." || !segmentPattern.test(segment);
+		});
+		if (invalidSourceSegment) {
+			failedRules.push({
+				rule: source,
+				reason: invalidSourceSegment === "." || invalidSourceSegment === ".." ? `Restriction segment "${invalidSourceSegment}" is not allowed.` : invalidSourceSegment.includes("**") ? `Invalid restriction segment "${invalidSourceSegment}". "**" must be its own path segment.` : `Restriction segment "${invalidSourceSegment}" contains unsupported characters.`
+			});
+			continue;
+		}
+		parsedRules.push({
+			method: "*",
+			pathPattern: source,
 			source
-		};
+		});
 	}
 	return {
-		method: "*",
-		pathPattern: normalizeAndValidateRestrictionPath(source),
-		source
+		parsedRules,
+		failedRules
 	};
 }
+//#endregion
+//#region src/utils/restriction-matcher.ts
 function escapeRestrictionRegex(value) {
 	let escaped = "";
 	for (const char of value) escaped += "\\^$.*+?()[]{}|".includes(char) ? `\\${char}` : char;
@@ -85429,13 +85509,13 @@ function compileRestrictionSegment(segment) {
 }
 function matchCompiledSegments(pattern, path, pi = 0, si = 0) {
 	while (pi < pattern.length) {
-		const seg = pattern[pi];
-		if (seg === "**") {
+		const segment = pattern[pi];
+		if (segment === "**") {
 			if (pi === pattern.length - 1) return true;
 			for (let i = si; i <= path.length; i++) if (matchCompiledSegments(pattern, path, pi + 1, i)) return true;
 			return false;
 		}
-		if (si >= path.length || !(seg instanceof RegExp) || !seg.test(path[si])) return false;
+		if (si >= path.length || !(segment instanceof RegExp) || !segment.test(path[si])) return false;
 		pi++;
 		si++;
 	}
@@ -85450,69 +85530,14 @@ function compileRestrictionRule(rule) {
 function matchesCompiledRule(rule, method, pathSegments) {
 	return (rule.method === "*" || rule.method === method) && matchCompiledSegments(rule.segments, pathSegments);
 }
-function compileRestrictionSources(restrictionSources) {
-	return restrictionSources.map(parseRestrictionRule).map(compileRestrictionRule);
-}
-function getBlockedCompiledRestrictions(compiledRestrictions, method, pathname) {
-	const normalizedMethod = String(method ?? "GET").trim().toUpperCase() || "GET";
-	const normalizedPath = normalizeRestrictionMatchPath(pathname);
-	const pathSegments = normalizedPath === "/" ? [] : normalizedPath.slice(1).split("/");
-	return compiledRestrictions.filter((rule) => matchesCompiledRule(rule, normalizedMethod, pathSegments));
-}
-//#endregion
-//#region src/utils/restrictions.ts
-const RESTRICTION_EXTENSION_KEY = "x-mc8yp-restrictions";
-const RESTRICTED_OPERATION_FLAG = "x-mc8yp-restricted";
-const RESTRICTED_OPERATION_MESSAGE = "x-mc8yp-restrictionMessage";
-const RESTRICTED_OPERATION_RULES = "x-mc8yp-restrictionRules";
-const RESTRICTED_OPERATION_TYPE = "x-mc8yp-restrictionType";
-const RESTRICTED_AGENT_NOTE = "x-mc8yp-agentNote";
-const HTTP_METHOD_SET = new Set(HTTP_METHODS);
-function normalizePath(value) {
-	let raw = value.trim();
-	if (!raw) return "/";
-	try {
-		if (/^[A-Za-z][A-Za-z\d+\-.]*:\/\//.test(raw)) raw = new URL(raw).pathname || "/";
-	} catch {}
-	raw = (raw.split("#", 1)[0] ?? raw).split("?", 1)[0] ?? raw;
-	raw = raw.startsWith("/") ? raw : `/${raw}`;
-	raw = raw.replace(/\/{2,}/g, "/");
-	return raw.length > 1 && raw.endsWith("/") ? raw.slice(0, -1) : raw || "/";
-}
-function normalizeMethod(value) {
-	const upper = value?.trim().toUpperCase() || "GET";
-	if (HTTP_METHOD_SET.has(upper)) return upper;
-	throw new Error(`Unsupported HTTP method "${value}".`);
-}
-function evaluateRestrictions(rules, method, path) {
-	const m = normalizeMethod(method);
-	const p = normalizePath(path);
-	const segs = p === "/" ? [] : p.slice(1).split("/");
-	return {
-		method: m,
-		path: p,
-		matchingRules: rules.filter((rule) => matchesCompiledRule(compileRestrictionRule(rule), m, segs))
-	};
-}
-function createNetworkPermissionDecision(tenantUrl, request, rules = []) {
-	const tenantHostname = new URL(tenantUrl).hostname;
-	if (request.op !== "connect") return {
-		allow: false,
-		reason: `Unsupported network operation "${request.op}". Only "connect" is allowed.`
-	};
-	if (request.hostname !== tenantHostname) return {
-		allow: false,
-		reason: `Network connect blocked: only ${tenantHostname} is allowed in execute mode.`
-	};
-	if (typeof request.method === "string") {
-		const requestPath = typeof request.url === "string" ? new URL(request.url).pathname : "/";
-		const restrictionMatch = evaluateRestrictions(rules, request.method, requestPath);
-		if (restrictionMatch.matchingRules.length > 0) return {
-			allow: false,
-			reason: `Network connect blocked by MCP restrictions: ${restrictionMatch.matchingRules.map((rule) => rule.source).join(", ")}`
-		};
-	}
-	return { allow: true };
+function findBlockingRestrictions(rules, method, pathname) {
+	const normalizedMethod = typeof method === "string" ? method.trim().toUpperCase() : "";
+	const pathSegments = pathname === "/" ? [] : pathname.slice(1).split("/");
+	return rules.filter((rule) => {
+		const compiledRule = compileRestrictionRule(rule);
+		if (!normalizedMethod) return compiledRule.method === "*" && matchCompiledSegments(compiledRule.segments, pathSegments);
+		return matchesCompiledRule(compiledRule, normalizedMethod, pathSegments);
+	});
 }
 //#endregion
 //#region src/codemode/openapi-restrictions.ts
@@ -85594,6 +85619,27 @@ var AsyncSemaphore = class {
 	}
 };
 //#endregion
+//#region src/codemode/network-permissions.ts
+function createNetworkPermissionDecision(tenantUrl, request, rules = []) {
+	const tenantHostname = new URL(tenantUrl).hostname;
+	if (request.op !== "connect") return {
+		allow: false,
+		reason: `Unsupported network operation "${request.op}". Only "connect" is allowed.`
+	};
+	if (request.hostname !== tenantHostname) return {
+		allow: false,
+		reason: `Network connect blocked: only ${tenantHostname} is allowed in execute mode.`
+	};
+	if (typeof request.url === "string") {
+		const blockingRules = findBlockingRestrictions(rules, typeof request.method === "string" ? request.method.trim() : void 0, new URL(request.url).pathname);
+		if (blockingRules.length > 0) return {
+			allow: false,
+			reason: `Network connect blocked by MCP restrictions: ${blockingRules.map((rule) => rule.source).join(", ")}`
+		};
+	}
+	return { allow: true };
+}
+//#endregion
 //#region node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
 function __awaiter(thisArg, _arguments, P, generator) {
 	function adopt(value) {
@@ -142373,16 +142419,15 @@ const runtimeSemaphore = new AsyncSemaphore(3);
 const BLOCKED_REQUEST_PREFIX = "Request blocked by MCP connection policy.";
 function serializeExecuteConfig(tenantUrl, headers, restrictions) {
 	const normalizedTenantUrl = new URL(tenantUrl).toString();
-	const restrictionSources = restrictions.map((rule) => {
-		const parsedRule = parseRestrictionRule(rule.source);
-		if (parsedRule.method !== rule.method || parsedRule.pathPattern !== rule.pathPattern) throw new TypeError(`Restriction source "${rule.source}" does not match its parsed shape.`);
-		return parsedRule.source;
-	});
+	const serializedRestrictions = restrictions.map(({ method, pathPattern, source }) => ({
+		method,
+		pathPattern,
+		source
+	}));
 	return JSON.stringify({
 		tenantUrl: normalizedTenantUrl,
-		tenantOrigin: new URL(normalizedTenantUrl).origin,
 		authHeaders: headers,
-		restrictionSources
+		restrictions: serializedRestrictions
 	});
 }
 function createQueryRuntime() {
@@ -142436,19 +142481,15 @@ function buildExecutePrelude(tenantUrl, headers, restrictions = []) {
 		"  if (!config || typeof config !== \"object\") {",
 		"    throw new TypeError(\"Invalid execute configuration.\");",
 		"  }",
-		"  const { tenantUrl, tenantOrigin, authHeaders, restrictionSources } = config;",
-		"  if (typeof tenantUrl !== \"string\" || typeof tenantOrigin !== \"string\") {",
-		"    throw new TypeError(\"Execute configuration must contain string tenant values.\");",
+		"  const { tenantUrl, authHeaders, restrictions } = config;",
+		"  if (typeof tenantUrl !== \"string\") {",
+		"    throw new TypeError(\"Execute configuration must contain a string tenant URL.\");",
 		"  }",
-		"  if (!Array.isArray(restrictionSources) || restrictionSources.some((source) => typeof source !== \"string\")) {",
-		"    throw new TypeError(\"Execute configuration must contain string restriction sources.\");",
+		"  if (!Array.isArray(restrictions) || restrictions.some((rule) => !rule || typeof rule !== \"object\" || typeof rule.method !== \"string\" || typeof rule.pathPattern !== \"string\" || typeof rule.source !== \"string\")) {",
+		"    throw new TypeError(\"Execute configuration must contain valid restriction rules.\");",
 		"  }",
 		"  const resolveUrl = (descriptor) => {",
-		"    const resolved = new URL(descriptor, tenantUrl.endsWith(\"/\") ? tenantUrl : tenantUrl + \"/\");",
-		"    if (resolved.origin !== tenantOrigin) {",
-		"      throw new Error(\"Cumulocity requests must target the configured tenant origin.\");",
-		"    }",
-		"    return resolved;",
+		"    return new URL(descriptor, tenantUrl.endsWith(\"/\") ? tenantUrl : tenantUrl + \"/\");",
 		"  };",
 		"  const normalizeRequest = (options) => {",
 		"    if (!options || typeof options !== \"object\") {",
@@ -142457,18 +142498,34 @@ function buildExecutePrelude(tenantUrl, headers, restrictions = []) {
 		"    const { path, ...rest } = options;",
 		"    return { path, init: rest };",
 		"  };",
-		`  const HTTP_METHOD_SET = new Set(${JSON.stringify(HTTP_METHODS)});`,
-		`  const normalizeRestrictionMatchPath = ${normalizeRestrictionMatchPath.toString()};`,
-		`  const normalizeAndValidateRestrictionPath = ${normalizeAndValidateRestrictionPath.toString()};`,
-		`  const parseRestrictionRule = ${parseRestrictionRule.toString()};`,
+		`  const HTTP_METHODS = ${JSON.stringify(HTTP_METHODS)};`,
+		"  const HTTP_METHOD_SET = new Set(HTTP_METHODS);",
 		`  const escapeRestrictionRegex = ${escapeRestrictionRegex.toString()};`,
 		`  const compileRestrictionSegment = ${compileRestrictionSegment.toString()};`,
 		`  const matchCompiledSegments = ${matchCompiledSegments.toString()};`,
 		`  const compileRestrictionRule = ${compileRestrictionRule.toString()};`,
 		`  const matchesCompiledRule = ${matchesCompiledRule.toString()};`,
-		`  const compileRestrictionSources = ${compileRestrictionSources.toString()};`,
-		`  const getBlockedCompiledRestrictions = ${getBlockedCompiledRestrictions.toString()};`,
-		"  const compiledRestrictions = compileRestrictionSources(restrictionSources);",
+		"  const compiledRestrictions = restrictions.map(compileRestrictionRule);",
+		"  const findBlockingRestrictions = (method, pathname) => {",
+		"    const normalizedMethod = typeof method === \"string\" ? method.trim().toUpperCase() : \"\";",
+		"    const pathSegments = pathname === \"/\" ? [] : pathname.slice(1).split(\"/\");",
+		"    return compiledRestrictions.filter((rule) => {",
+		"      if (!normalizedMethod) {",
+		"        return rule.method === \"*\" && matchCompiledSegments(rule.segments, pathSegments);",
+		"      }",
+		"      return matchesCompiledRule(rule, normalizedMethod, pathSegments);",
+		"    });",
+		"  };",
+		"  const validateRequestMethod = (method) => {",
+		"    if (typeof method !== \"string\" || method.trim().length === 0) {",
+		"      throw new TypeError(\"request method must be a non-empty string\");",
+		"    }",
+		"    const normalizedMethod = method.trim().toUpperCase();",
+		"    if (!HTTP_METHOD_SET.has(normalizedMethod)) {",
+		"      throw new TypeError(\"request method must be one of: \" + HTTP_METHODS.join(\", \"));",
+		"    }",
+		"    return normalizedMethod;",
+		"  };",
 		"  const formatBlockedRequestMessage = (method, path, matchingRules) => [",
 		"    \"Request blocked by MCP connection policy.\",",
 		"    \"\",",
@@ -142514,10 +142571,10 @@ function buildExecutePrelude(tenantUrl, headers, restrictions = []) {
 		"      if (typeof path !== \"string\" || path.length === 0) {",
 		"        throw new TypeError(\"request path must be a non-empty string\");",
 		"      }",
+		"      const method = validateRequestMethod(init.method);",
 		"      const resolvedUrl = resolveUrl(path);",
-		"      const blockedRules = getBlockedCompiledRestrictions(compiledRestrictions, init.method, resolvedUrl.pathname);",
+		"      const blockedRules = findBlockingRestrictions(method, resolvedUrl.pathname);",
 		"      if (blockedRules.length > 0) {",
-		"        const method = typeof init.method === \"string\" && init.method.trim() ? init.method.trim().toUpperCase() : \"GET\";",
 		"        throw new Error(formatBlockedRequestMessage(method, resolvedUrl.pathname, blockedRules.map((rule) => rule.source)));",
 		"      }",
 		"      const headers = new Headers(init.headers ?? {});",
@@ -142528,6 +142585,7 @@ function buildExecutePrelude(tenantUrl, headers, restrictions = []) {
 		"      const requestHeaders = Object.fromEntries(headers.entries());",
 		"      const response = await fetch(resolvedUrl.toString(), {",
 		"        ...init,",
+		"        method,",
 		"        headers: requestHeaders,",
 		"        body,",
 		"      });",
@@ -142826,7 +142884,7 @@ function createC8YMcpServer() {
 		capabilities: {
 			tools: { listChanged: true },
 			prompts: { listChanged: true },
-			resources: { listChanged: false }
+			resources: { listChanged: true }
 		}
 	}).withContext();
 	server.tools(createTools(server));
@@ -142943,7 +143001,8 @@ runMain(defineCommand({
 		setCoreOpenApiVersion(selected.version);
 		consola.info(`Using core OpenAPI snapshot: ${getCoreOpenApiLabel()}`);
 		const raw = args.restriction;
-		const restrictions = (Array.isArray(raw) ? raw : raw ? [raw] : []).filter(Boolean).map(parseRestrictionRule);
+		const { parsedRules: restrictions, failedRules } = parseRestrictionRule((Array.isArray(raw) ? raw : raw ? [raw] : []).filter((value) => typeof value === "string" && value.length > 0));
+		if (failedRules.length > 0) throw new Error(["One or more restriction flags could not be parsed:", ...failedRules.map((rule) => `- ${rule.rule}: ${rule.reason}`)].join("\n"));
 		if (restrictions.length > 0) consola.info(`Applying ${restrictions.length} restriction rule(s):`, restrictions.map((r) => r.source));
 		const transport = new StdioTransport(createC8YMcpServer());
 		consola.info("Starting MCP server over stdio transport...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc8yp",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "description": "Cumulocity IoT MCP Server - Model Context Protocol integration for IoT device management",
   "keywords": [
@@ -49,6 +49,7 @@
   "devDependencies": {
     "@schplitt/eslint-config": "^1.4.0",
     "@types/node": "^24.12.2",
+    "changelogithub": "^14.0.0",
     "eslint": "^9.39.4",
     "tsdown": "^0.21.9",
     "typescript": "^5.9.3",