@utilix-tech/mcp 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 Full release notes for all Utilix surfaces (browser tools, REST API, SDKs, MCP server) live at [utilix.tech/changelog](https://utilix.tech/changelog). This file tracks just this package.
 
+## 0.43.0
+- Add `build_vary_header`, `parse_vary_header` tools: build a `Vary` response header from request-header names with a plain-English caching note per header, or parse an existing Vary header into the same shape.
+
 ## 0.42.0
 - Add `build_range_header`, `parse_content_range_header` tools: build an HTTP `Range` request header from explicit, open-ended, or suffix ("last N bytes") byte ranges, and parse a server's `Content-Range` response to verify what it actually sent back.
 - Add `find_csv_duplicate_rows` tool: group CSV/TSV rows that share the same value across a chosen set of key columns, or the entire row, and report each duplicate group's occurrence count and data row numbers.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 171 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 173 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
 
 No API key required. All tools run locally. Requires Node.js 18 or later.
 
@@ -189,7 +189,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_cash_breakdown` | Break a cash amount down into the minimum count of bills/coins from a set of denominations, largest first |
 | `calculate_change` | Compute change owed for a payment/tender pair and break it down into the minimum count of bills/coins |
 
-### API / Network (18 tools)
+### API / Network (20 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -210,6 +210,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `analyze_email_headers` | Parse a raw email header block into structured fields, the Received hop chain, and SPF/DKIM/DMARC results from an Authentication-Results header |
 | `build_range_header` | Build an HTTP Range request header from explicit, open-ended, or suffix ("last N bytes") byte ranges |
 | `parse_content_range_header` | Parse a Content-Range response header into its unit, byte bounds, and total resource size |
+| `build_vary_header` | Build a Vary response header from request-header names, with a plain-English caching note per header |
+| `parse_vary_header` | Parse an existing Vary header value into its individual header names, each with a caching note |
 
 ### Color (4 tools)
 | Tool | Description |

package/dist/index.js

@@ -7136,5 +7136,67 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _VARY_HEADER_NOTES_MCP = {
+  "accept-encoding": "Caches must store a separate response per compression scheme (gzip, br, etc.) the client accepts.",
+  "accept-language": "Caches must store a separate response per requested language, which can fragment a shared cache badly if Accept-Language values are highly varied.",
+  "accept": "Caches must store a separate response per requested content type (e.g. JSON vs HTML).",
+  "user-agent": "Caches must store a separate response per distinct User-Agent string, which is often unique enough to make caching nearly ineffective.",
+  "authorization": "Signals the response is user-specific; most shared caches will refuse to cache it at all rather than key on this header.",
+  "cookie": "Same effect as Authorization: shared caches typically treat the response as private and skip caching rather than key on cookie values.",
+  "origin": "Caches must store a separate response per requesting Origin, needed whenever a response includes CORS headers that differ by origin.",
+  "x-requested-with": "Caches must store a separate response depending on whether the request was made via an XHR/fetch client hint.",
+  "x-forwarded-proto": "Caches must store a separate response for HTTP vs HTTPS requests, relevant behind a proxy or load balancer that terminates TLS."
+};
+function _buildVaryHeaderMcp(headers) {
+  if (!Array.isArray(headers) || headers.length === 0) return { error: "At least one header is required" };
+  const trimmed = headers.map((h) => typeof h === "string" ? h.trim() : "").filter((h) => h.length > 0);
+  if (trimmed.length === 0) return { error: "At least one header is required" };
+  const warnings = [];
+  if (trimmed.some((h) => h === "*") && trimmed.length > 1) {
+    warnings.push('"*" makes every request effectively uncacheable; combining it with other header names is redundant, most caches will just skip caching entirely');
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const h of trimmed) {
+    const key = h.toLowerCase();
+    if (!seen.has(key)) seen.set(key, h);
+  }
+  if (seen.size < trimmed.length) warnings.push("duplicate header names were removed");
+  const entries = Array.from(seen.values()).map((h) => ({
+    header: h,
+    note: h === "*" ? "Every response is considered unique; most caches will not store it at all." : _VARY_HEADER_NOTES_MCP[h.toLowerCase()] ?? `Caches must store a separate response per distinct ${h} value.`
+  }));
+  const headerValue = entries.map((e) => e.header).join(", ");
+  return { header: `Vary: ${headerValue}`, headerValue, entries, warnings };
+}
+function _parseVaryHeaderMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const withoutLabel = raw.trim().replace(/^vary:\s*/i, "");
+  const headers = withoutLabel.split(",").map((h) => h.trim()).filter((h) => h.length > 0);
+  return _buildVaryHeaderMcp(headers);
+}
+server.tool(
+  "build_vary_header",
+  "Build a Vary response-header value from a list of request-header names (e.g. Accept-Encoding, Accept-Language, Authorization), de-duplicating case-insensitively and attaching a plain-English caching note for each well-known header explaining what it does to shared caches.",
+  {
+    headers: z.array(z.string()).min(1).describe("Request-header names to vary the response by")
+  },
+  async ({ headers }) => {
+    const result = _buildVaryHeaderMcp(headers);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_vary_header",
+  'Parse an existing Vary header value (with or without a leading "Vary:" label) into its individual header names, each with a plain-English note on what it does to shared caching.',
+  {
+    header: z.string().min(1).describe("The Vary header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parseVaryHeaderMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "MCP server exposing 168 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",