@fruggr/zendesk-mcp-server 2.17.1 → 2.18.0

package/dist/index.js

@@ -126,7 +126,6 @@ const positiveIntEnv = (name, fallback) => {
 	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
 };
 const ARTICLE_RESOURCES_SCAN_MAX_PAGES = positiveIntEnv("ZENDESK_ARTICLE_RESOURCES_SCAN_MAX_PAGES", 20);
-const TRANSLATION_GAP_SCAN_MAX_NODES = positiveIntEnv("ZENDESK_TRANSLATION_GAP_SCAN_MAX_NODES", 60);
 const MAX_ATTACHMENT_BYTES = positiveIntEnv("ZENDESK_MAX_ATTACHMENT_BYTES", 5242880);
 const MAX_EMBEDDED_IMAGE_COUNT = positiveIntEnv("ZENDESK_MAX_EMBEDDED_IMAGES", 10);
 const MAX_COMMENT_PAGES = positiveIntEnv("ZENDESK_MAX_COMMENT_PAGES", 10);
@@ -813,26 +812,195 @@ const loadConfig = (argv = process.argv.slice(2)) => {
 	});
 };
 //#endregion
+//#region src/client/retry.ts
+const MAX_ATTEMPTS = 3;
+const BASE_DELAY_MS = 250;
+const MAX_DELAY_MS = 4e3;
+const REQUEST_TIMEOUT_MS = 3e4;
+const TRANSFER_TIMEOUT_MS = 12e4;
+/**
+* A deadline for one attempt. The abort surfaces as a `TimeoutError` whose `code`
+* is numeric, not a syscall string, so it classifies as `unknown`: a GET is
+* retried, a write is not — the request may have arrived before the deadline.
+*/
+const deadlineSignal = (timeoutMs) => AbortSignal.timeout(timeoutMs);
+const MAX_RETRY_AFTER_MS = 5e3;
+const POLICIES = {
+	GET: {
+		network: "any",
+		serverErrors: true
+	},
+	DELETE: {
+		network: "pre-send",
+		serverErrors: false
+	},
+	POST: {
+		network: "pre-send",
+		serverErrors: false
+	},
+	PUT: {
+		network: "pre-send",
+		serverErrors: false
+	}
+};
+const DELAY_SECONDS = /^\d+$/;
+const HTTP_DATE_START = /^[A-Za-z]/;
+const NON_ASCII = /[^ -~]/g;
+const TOKEN_SEGMENT = /\/token\/[^/]+/;
+const URL_IN_TEXT = /[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+const PRE_SEND_CODES = /* @__PURE__ */ new Set([
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const defaultRetryDeps = {
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+	random: Math.random
+};
+/** Non-ASCII bytes break `node:http` headers, so client error text stays ASCII. */
+const toAscii = (text) => text.replace(NON_ASCII, "?");
+/**
+* Identifies the request without leaking a credential: uploads carry an upload
+* token in the query string, and an attachment `content_url` carries a download
+* token as a path segment (`/attachments/token/<token>/`).
+*/
+const describeTarget = (url) => {
+	const { origin, pathname } = new URL(url);
+	return `${origin}${pathname.replace(TOKEN_SEGMENT, "/token/[redacted]")}`;
+};
+/** First `code` in the cause chain, inspecting 5 levels so a cycle cannot hang. */
+const errorCode = (err) => {
+	let current = err;
+	for (let depth = 0; depth < 5 && current !== null && typeof current === "object"; depth += 1) {
+		const { code, cause } = current;
+		if (typeof code === "string") return code;
+		current = cause;
+	}
+};
+const classifyNetworkError = (err) => PRE_SEND_CODES.has(errorCode(err)) ? "pre-send" : "unknown";
+const UNINFORMATIVE_NAMES = /* @__PURE__ */ new Set(["Error", "TypeError"]);
+/**
+* The client refuses to replay a write that may have landed — but the caller is
+* an LLM whose reflex on a failed tool call is to try again, which would undo
+* that. So a failed write says whether it may have taken effect. ASCII only,
+* same rule as the rest of the message.
+*/
+const MAY_HAVE_APPLIED_NOTE = "The write may already have been applied. Check the current state before retrying, or you may duplicate it.";
+const NEVER_SENT_NOTE = "The request never reached Zendesk, so nothing was applied. Retrying is safe.";
+const REFUSED_NOTE = "Zendesk refused the request, so nothing was applied. Retrying is safe.";
+/** Only a write can be duplicated by a replay, so only a write carries a note. */
+const writeNote = (method, note) => method === "GET" ? "" : ` ${note}`;
+/**
+* A cause message can quote the URL it failed on — Node's `fetch` refuses a URL
+* carrying credentials by printing the whole thing, query string included — which
+* would smuggle back exactly what `describeTarget` drops. Same treatment for both,
+* so one function owns what a URL may look like in our output.
+*/
+const redactUrls = (text) => text.replace(URL_IN_TEXT, (found) => {
+	try {
+		return new URL(found).origin === "null" ? "[url]" : describeTarget(found);
+	} catch {
+		return "[url]";
+	}
+});
+const failureDetail = (cause) => {
+	if (!(cause instanceof Error)) return redactUrls(String(cause));
+	const message = redactUrls(cause.message);
+	const code = errorCode(cause);
+	if (code !== void 0) return `${code}: ${message}`;
+	return UNINFORMATIVE_NAMES.has(cause.name) ? message : `${cause.name}: ${message}`;
+};
+const networkErrorMessage = (method, target, attempts, cause) => {
+	const base = `Network error on ${method} ${target} after ${attempts === 1 ? "1 attempt" : `${attempts} attempts`}: ${failureDetail(cause)}`;
+	const note = classifyNetworkError(cause) === "pre-send" ? NEVER_SENT_NOTE : MAY_HAVE_APPLIED_NOTE;
+	return toAscii(method === "GET" ? base : `${base}.${writeNote(method, note)}`);
+};
+const createZendeskNetworkError = (method, target, attempts, cause) => Object.assign(new Error(networkErrorMessage(method, target, attempts, cause), { cause }), {
+	name: "ZendeskNetworkError",
+	method,
+	target,
+	attempts
+});
+/** Exponential backoff with equal jitter: half the window fixed, half random. */
+const computeBackoffMs = (attempt, random) => {
+	const window = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS);
+	return Math.round(window / 2 + window * random() / 2);
+};
+/** `Retry-After` in ms — delay-seconds or HTTP-date. */
+const parseRetryAfter = (header, now = Date.now()) => {
+	if (header === null) return void 0;
+	const value = header.trim();
+	if (DELAY_SECONDS.test(value)) return Number(value) * 1e3;
+	if (!HTTP_DATE_START.test(value)) return void 0;
+	const date = Date.parse(value);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, date - now);
+};
+/**
+* How long to wait before replaying this response, or undefined to accept it.
+* `Retry-After` wins over backoff wherever it appears — Zendesk sends it on a 503
+* during maintenance as well as on a 429 — and a value past the cap means the
+* response is surfaced rather than parking the call for that long.
+*/
+const retryDelayFor = (response, policy, attempt, random) => {
+	if (!(response.status === 429 || response.status >= 500 && policy.serverErrors)) return void 0;
+	const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+	if (retryAfter === void 0) return computeBackoffMs(attempt, random);
+	return retryAfter > MAX_RETRY_AFTER_MS ? void 0 : retryAfter;
+};
+/**
+* Runs `attempt` until it succeeds, hits a terminal outcome, or spends the
+* attempt budget. Returns the last response for the caller to inspect (a
+* non-ok status is still the caller's to turn into a `ZendeskApiError`), and
+* throws `ZendeskNetworkError` when no response was ever obtained.
+*/
+const fetchWithRetry = async (attempt, method, target, deps = defaultRetryDeps) => {
+	const policy = POLICIES[method];
+	for (let tries = 1;; tries += 1) {
+		const last = tries >= MAX_ATTEMPTS;
+		let response;
+		try {
+			response = await attempt();
+		} catch (err) {
+			const replayable = policy.network === "any" || classifyNetworkError(err) === policy.network;
+			if (last || !replayable) throw createZendeskNetworkError(method, target, tries, err);
+			await deps.sleep(computeBackoffMs(tries, deps.random));
+			continue;
+		}
+		if (last) return response;
+		const delayMs = retryDelayFor(response, policy, tries, deps.random);
+		if (delayMs === void 0) return response;
+		await response.text().catch(() => void 0);
+		await deps.sleep(delayMs);
+	}
+};
+//#endregion
 //#region src/client/zendesk-api.ts
 var ZendeskApiError = class ZendeskApiError extends Error {
 	status;
 	statusText;
 	body;
-	constructor(status, statusText, body) {
-		super(ZendeskApiError.buildMessage(status, statusText, body));
+	method;
+	constructor(status, statusText, body, method) {
+		super(ZendeskApiError.buildMessage(status, statusText, body, method));
 		this.status = status;
 		this.statusText = statusText;
 		this.body = body;
+		this.method = method;
 		this.name = "ZendeskApiError";
 	}
-	static buildMessage(status, statusText, body) {
+	static buildMessage(status, statusText, body, method) {
 		switch (status) {
 			case 401: return "Authentication failed. Your Zendesk token may be expired or invalid. Re-authenticate to get a new token.";
 			case 403: return "Permission denied. Your Zendesk account does not have access to this resource.";
 			case 404: return `Resource not found. Please verify the ID is correct. (${statusText})`;
 			case 422: return `Validation error: ${body}`;
-			case 429: return "Rate limit exceeded. Please wait before making more requests.";
-			default: return `Zendesk API error ${status}: ${statusText}. ${body}`;
+			case 429: return `Rate limit exceeded. Please wait before making more requests.${writeNote(method, REFUSED_NOTE)}`;
+			default: {
+				const message = `Zendesk API error ${status}: ${statusText}. ${body}`;
+				return status >= 500 ? `${message}${writeNote(method, MAY_HAVE_APPLIED_NOTE)}` : message;
+			}
 		}
 	}
 };
@@ -842,6 +1010,11 @@ const buildUrl = (base, path, params) => {
 	if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
 	return url.toString();
 };
+const performFetch = (method, url, init, timeoutMs = REQUEST_TIMEOUT_MS) => fetchWithRetry(() => fetch(url, {
+	...init,
+	method,
+	signal: deadlineSignal(timeoutMs)
+}), method, describeTarget(url));
 const executeRequest = async (url, token, options = {}) => {
 	const { method = "GET", body } = options;
 	const headers = {
@@ -849,15 +1022,12 @@ const executeRequest = async (url, token, options = {}) => {
 		Accept: "application/json"
 	};
 	if (body) headers["Content-Type"] = "application/json";
-	const init = {
-		method,
-		headers
-	};
+	const init = { headers };
 	if (body) init.body = JSON.stringify(body);
-	const response = await fetch(url, init);
+	const response = await performFetch(method, url, init);
 	if (!response.ok) {
 		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody);
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, method);
 	}
 	if (response.status === 204) return {};
 	return response.json();
@@ -906,10 +1076,10 @@ const fetchZendeskBinary = async (subdomain, token, contentUrl) => {
 	const expectedHost = `${subdomain}.zendesk.com`;
 	const headers = {};
 	if (new URL(contentUrl).hostname === expectedHost) headers["Authorization"] = buildAuthHeader(token);
-	const response = await fetch(contentUrl, { headers });
+	const response = await performFetch("GET", contentUrl, { headers }, TRANSFER_TIMEOUT_MS);
 	if (!response.ok) {
 		const body = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, body);
+		throw new ZendeskApiError(response.status, response.statusText, body, "GET");
 	}
 	const contentType = response.headers.get("content-type") ?? "application/octet-stream";
 	const arrayBuffer = await response.arrayBuffer();
@@ -922,30 +1092,28 @@ const zendeskUpload = async (subdomain, token, filename, data, contentType, uplo
 	const params = { filename };
 	if (uploadToken) params["token"] = uploadToken;
 	const url = buildUrl(getBaseUrl(subdomain), "/uploads", params);
-	const response = await fetch(url, {
-		method: "POST",
+	const response = await performFetch("POST", url, {
 		headers: {
 			Authorization: buildAuthHeader(token),
 			"Content-Type": contentType
 		},
 		body: data
-	});
+	}, TRANSFER_TIMEOUT_MS);
 	if (!response.ok) {
 		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody);
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
 	}
 	return response.json();
 };
 const helpCenterUpload = async (subdomain, token, path, formData) => {
 	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
-	const response = await fetch(url, {
-		method: "POST",
+	const response = await performFetch("POST", url, {
 		headers: { Authorization: buildAuthHeader(token) },
 		body: formData
-	});
+	}, TRANSFER_TIMEOUT_MS);
 	if (!response.ok) {
 		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody);
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
 	}
 	return response.json();
 };
@@ -1802,6 +1970,7 @@ const nodeTranslationWriteText = (kind, nodeId, translation, created) => [
 	"",
 	formatNodeTranslationSummary(translation)
 ].join("\n");
+const TRANSLATIONS_SIDELOAD = "translations";
 const GAP_REASON_TEXT = {
 	missing: "no translation",
 	draft: "draft translation (not published)"
@@ -1819,40 +1988,49 @@ const classifyGap = (node, translations, locale) => {
 		reason: "draft"
 	} : null;
 };
+/**
+* Split a listing into the nodes that can be classified and the rest. A node
+* whose `translations` key is absent was answered without the sideload, and
+* reading that as "no translation" would report an entire Help Center as one big
+* gap — so it counts as unclassified and the report says how many.
+*/
+const withSideloadedTranslations = (nodes) => nodes.filter((node) => Array.isArray(node.translations));
 const renderGapLines = (heading, gaps, scanned, found) => {
 	const header = `## ${heading} (${scanned} scanned)`;
 	if (gaps.length > 0) return [header, ...gaps.map((gap) => `- **${gap.name}** (${gap.id}) — ${GAP_REASON_TEXT[gap.reason]}`)];
-	if (scanned === 0) return [header, found === 0 ? "_(none to scan at this level)_" : `_(none scanned — the ${TRANSLATION_GAP_SCAN_MAX_NODES}-node cap was spent before this level; ${found} left unchecked, see the note below)_`];
+	if (scanned === 0) return [header, found === 0 ? "_(none to scan at this level)_" : `_(none classified — the listing answered without the sideload for all ${found}, see the note below)_`];
 	return [header, "_(none — every one scanned has a published translation)_"];
 };
-const GAP_SCAN_WAVE_SIZE = 5;
-const probeInWaves = async (nodes, probe) => {
-	const gaps = [];
-	for (let i = 0; i < nodes.length; i += GAP_SCAN_WAVE_SIZE) {
-		const wave = await Promise.all(nodes.slice(i, i + GAP_SCAN_WAVE_SIZE).map(probe));
-		for (const gap of wave) if (gap !== null) gaps.push(gap);
-	}
-	return gaps;
-};
 const fetchGapCategories = async (subdomain, token, categoryId) => {
 	if (categoryId !== void 0) {
-		const { category } = await helpCenterGet(subdomain, token, `/categories/${categoryId}`);
+		const { category } = await helpCenterGet(subdomain, token, `/categories/${categoryId}`, { include: TRANSLATIONS_SIDELOAD });
 		return {
 			categories: [category],
 			hasMore: false
 		};
 	}
-	const response = await helpCenterGet(subdomain, token, "/categories", buildCursorParams(100, void 0));
+	const response = await helpCenterGet(subdomain, token, "/categories", {
+		...buildCursorParams(100, void 0),
+		include: TRANSLATIONS_SIDELOAD
+	});
 	const categories = response.categories ?? [];
 	return {
 		categories,
 		hasMore: extractPaginationMeta(response, categories.length).has_more
 	};
 };
+const renderGapVerdict = (report, gapCount, unclassified) => {
+	const { locale, scanned } = report;
+	if (gapCount > 0) return `${gapCount} node(s) need a published "${locale}" translation. Fix a category with set_category_translation and a section with set_section_translation, passing draft: false to publish.`;
+	if (scanned.categories + scanned.sections === 0 && unclassified > 0) return `Nothing could be classified, so this audit says nothing about "${locale}" either way. See the note below.`;
+	const allClear = `No gaps: all ${scanned.categories} category/ies and ${scanned.sections} section(s) scanned have a published "${locale}" translation.`;
+	return unclassified > 0 ? `${allClear} This is not a clean bill of health for the whole tree: ${unclassified} other node(s) could not be classified — see the note below.` : allClear;
+};
 const renderGapReport = (report) => {
 	const { locale, categoryGaps, sectionGaps, scanned, found } = report;
 	const gapCount = categoryGaps.length + sectionGaps.length;
-	const capped = scanned.categories < found.categories || scanned.sections < found.sections;
+	const totalFound = found.categories + found.sections;
+	const unclassified = totalFound - (scanned.categories + scanned.sections);
 	return truncateIfNeeded([
 		`# Translation gaps — "${locale}"`,
 		"",
@@ -1861,8 +2039,8 @@ const renderGapReport = (report) => {
 		"",
 		...renderGapLines("Sections", sectionGaps, scanned.sections, found.sections),
 		"",
-		gapCount === 0 ? `No gaps: all ${scanned.categories} category/ies and ${scanned.sections} section(s) scanned have a published "${locale}" translation.` : `${gapCount} node(s) need a published "${locale}" translation. Fix a category with set_category_translation and a section with set_section_translation, passing draft: false to publish.`,
-		...capped ? ["", `_Note: the scan stopped at its ${TRANSLATION_GAP_SCAN_MAX_NODES}-node cap, covering ${scanned.categories}/${found.categories} categories and ${scanned.sections}/${found.sections} sections. The rest were not checked — narrow the scan with category_id, or raise ZENDESK_TRANSLATION_GAP_SCAN_MAX_NODES._`] : [],
+		renderGapVerdict(report, gapCount, unclassified),
+		...unclassified > 0 ? ["", `_Note: ${unclassified} of ${totalFound} node(s) came back without the \`translations\` sideload, so their state is unknown and none of them is reported above (covered: ${scanned.categories}/${found.categories} categories, ${scanned.sections}/${found.sections} sections). Read one of them with list_category_translations / list_section_translations, which query the node directly._`] : [],
 		...report.listingIncomplete ? ["", `_Note: this Help Center has more than 100 categories or sections, so only the first page of each was considered. Narrow the scan with category_id to audit the rest._`] : []
 	].join("\n"));
 };
@@ -2302,10 +2480,10 @@ const createHelpCenterTools = (ctx) => {
 			namespace: "help_center",
 			readOnly: true,
 			title: "Find Help Center Translation Gaps",
-			description: "Audit the Help Center tree for a target locale and report every category and section that has no translation, or one that is still an unpublished draft. Use it before or after translating articles: an article published in a second locale is unreachable while its parent section only exists in the source locale. Listing sections in that locale cannot answer this — a node with no translation is simply absent, without saying why, and a node whose translation is an unpublished draft may still be listed under its draft name — so this audit reads the draft flag on each node instead of trusting that listing. Costs one extra request per node scanned, capped (the report says so when the cap bites) — pass category_id to narrow it. Fix what it reports with set_section_translation / set_category_translation.",
+			description: "Audit the Help Center tree for a target locale and report every category and section that has no translation, or one that is still an unpublished draft. Use it before or after translating articles: an article published in a second locale is unreachable while its parent section only exists in the source locale. Listing sections in that locale cannot answer this — a node with no translation is simply absent, without saying why, and a node whose translation is an unpublished draft may still be listed under its draft name — so this audit reads the draft flag on each node instead of trusting that listing. Costs two listings and covers up to 100 categories and 100 sections; past that only the first page of each level is audited, and the report says so — pass category_id to narrow it. Fix what it reports with set_section_translation / set_category_translation.",
 			inputSchema: z.object({
 				locale: z.string().describe("Locale to audit, e.g. \"fr\" or \"de\" — usually a non-default active locale of the Help Center (zendesk-hc://topology lists them). A locale that is not active is reported as a warning, since every node would then look untranslated."),
-				category_id: z.number().int().optional().describe("Restrict the audit to this category and the sections it contains (id from list_categories). Omit to sweep the whole tree, which costs one request per category and per section.")
+				category_id: z.number().int().optional().describe("Restrict the audit to this category and the sections it contains (id from list_categories). Omit to sweep the whole tree, which costs two listings and covers up to 100 categories and 100 sections.")
 			}),
 			annotations: {
 				readOnlyHint: true,
@@ -2319,14 +2497,17 @@ const createHelpCenterTools = (ctx) => {
 				const [locales, categoryScope, sectionsRes] = await Promise.all([
 					helpCenterGet(subdomain, token, "/locales"),
 					fetchGapCategories(subdomain, token, category_id),
-					helpCenterGet(subdomain, token, sectionListPath(category_id, void 0), buildCursorParams(100, void 0))
+					helpCenterGet(subdomain, token, sectionListPath(category_id, void 0), {
+						...buildCursorParams(100, void 0),
+						include: TRANSLATIONS_SIDELOAD
+					})
 				]);
 				const allCategories = categoryScope.categories;
 				const allSections = sectionsRes.sections ?? [];
-				const categories = allCategories.slice(0, TRANSLATION_GAP_SCAN_MAX_NODES);
-				const sections = allSections.slice(0, Math.max(0, TRANSLATION_GAP_SCAN_MAX_NODES - categories.length));
-				const categoryGaps = await probeInWaves(categories, async (category) => classifyGap(category, await listNodeTranslations(subdomain, token, "categories", category.id, locale), locale));
-				const sectionGaps = await probeInWaves(sections, async (section) => classifyGap(section, await listNodeTranslations(subdomain, token, "sections", section.id, locale), locale));
+				const categories = withSideloadedTranslations(allCategories);
+				const sections = withSideloadedTranslations(allSections);
+				const categoryGaps = categories.flatMap((category) => classifyGap(category, category.translations, locale) ?? []);
+				const sectionGaps = sections.flatMap((section) => classifyGap(section, section.translations, locale) ?? []);
 				return { content: [{
 					type: "text",
 					text: renderGapReport({
@@ -4581,8 +4762,10 @@ const readJsonBody = (req, maxBodyBytes) => new Promise((resolve) => {
 const respondBodyError = (req, res, failure) => {
 	const headers = failure.status === 413 ? { Connection: "close" } : {};
 	sendJsonRpcError(res, failure.status, failure.rpcCode, failure.message, headers);
-	if (failure.status === 413) if (res.writableFinished) req.destroy();
-	else res.once("finish", () => req.destroy());
+	if (failure.status === 413) {
+		if (res.writableFinished) req.destroy();
+		else res.once("finish", () => req.destroy());
+	}
 };
 const SESSION_IDLE_TIMEOUT_MS = 18e5;
 const SESSION_SWEEP_INTERVAL_MS = 6e4;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruggr/zendesk-mcp-server",
-  "version": "2.17.1",
+  "version": "2.18.0",
   "mcpName": "io.github.fruggr/zendesk-mcp-server",
   "description": "Deep Zendesk MCP server for your AI assistant: search, draft, update and translate Help Center articles and manage Support tickets end to end — comments, triage and image attachments.",
   "type": "module",
@@ -69,7 +69,7 @@
   "engines": {
     "node": ">=20"
   },
-  "packageManager": "pnpm@11.20.0+sha512.9a6f330a95b66446ea088faf1521405a8a01f07fde7124cc9958dfed52d4bb436737e65b08f85f37b46fcba375092558ac51262b816844b22f63406ed166bfee",
+  "packageManager": "pnpm@11.21.0+sha512.521705bce689924eac72f5a3587122f362689ef6571e55ba80076fd637c11132ecffada26fad4ea79c485bfddbfd3d5a2a5b05805a77e893de71ec8a6cca3bb1",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
     "cheerio": "1.2.0",
@@ -89,9 +89,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.7",
-    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/exec": "^7.1.0",
-    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/git": "^11.0.0",
     "@semantic-release/github": "^12.0.6",
     "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^14.1.1",