@utilix-tech/mcp 0.57.0 → 0.59.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 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.59.0
+- Add `build_prefer_header`, `parse_prefer_header` tools: build an HTTP Prefer request-header value from preferences with optional values and parameters per RFC 7240, or parse an existing one into the same shape.
+- Add `dedupe_ndjson` tool: remove duplicate records from NDJSON input, either by exact structural equality or by a chosen key field, keeping the first occurrence of each duplicate.
+
+## 0.58.0
+- Add `apply_json_merge_patch` tool: apply an RFC 7396 JSON Merge Patch document to a target JSON document, with null-valued patch keys removing the matching target key.
+- Add `generate_csp_nonce` tool: generate a cryptographically random, base64-encoded Content-Security-Policy nonce with ready-to-paste header directive and script/style tag snippets.
+
 ## 0.57.0
 - Add `build_accept_language`, `parse_accept_language` tools: build an Accept-Language request-header value from locale/quality pairs sorted by descending preference, or parse an existing one into its ranked entries.
 - Add `calculate_blended_loan_rate` tool: compute the single weighted-average interest rate across a list of loan balances, plus combined monthly and annual interest accrual.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 203 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 208 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.
 
@@ -75,7 +75,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 
 ## Tools
 
-### JSON (15 tools)
+### JSON (16 tools)
 | Tool | Description |
 |------|-------------|
 | `format_json` | Pretty-print and validate a JSON string |
@@ -85,6 +85,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `csv_to_json` | Convert CSV text to a JSON array |
 | `jsonpath` | Evaluate a JSONPath expression |
 | `resolve_json_pointer` | Resolve an RFC 6901 JSON Pointer against a JSON document |
+| `apply_json_merge_patch` | Apply an RFC 7396 JSON Merge Patch document to a target JSON document |
 | `validate_json` | Validate JSON against a JSON Schema |
 | `yaml_to_json` | Convert YAML to JSON |
 | `json_to_yaml` | Convert JSON to YAML |
@@ -120,7 +121,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `generate_sri_hash` | Compute a Subresource Integrity hash (SHA-256/384/512) for a script or stylesheet's content, formatted for an HTML `integrity` attribute |
 | `generate_etag` | Compute a content-hash ETag (MD5/SHA-1/SHA-256) for a response header, with an optional weak-validator prefix |
 
-### Generators (6 tools)
+### Generators (7 tools)
 | Tool | Description |
 |------|-------------|
 | `generate_uuid` | Generate UUID v4 or v7 |
@@ -129,6 +130,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `estimate_password_entropy` | Estimate a password's entropy in bits, strength label, and crack-time estimates |
 | `generate_qr` | Generate a QR code as an SVG string |
 | `generate_random_data` | Generate random mock data: names, emails, UUIDs, IPs, etc. |
+| `generate_csp_nonce` | Generate a cryptographically random CSP nonce with ready-to-paste header directive and script/style tag snippets |
 
 ### Text (16 tools)
 | Tool | Description |
@@ -233,6 +235,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `build_x_content_type_options_header` | Build the fixed X-Content-Type-Options: nosniff header, validate a pasted value, or assess MIME-sniffing risk for a given Content-Type |
 | `build_accept_language` | Build an Accept-Language request-header value from locale/quality pairs, sorted by descending preference |
 | `parse_accept_language` | Parse an existing Accept-Language header value into its ranked locale/quality pairs |
+| `build_prefer_header` | Build an HTTP Prefer request-header value from preferences with optional values/params, per RFC 7240 |
+| `parse_prefer_header` | Parse an existing Prefer header value into its list of preferences, values, and parameters |
 
 ### Color (4 tools)
 | Tool | Description |
@@ -270,6 +274,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `xml_to_json` | Convert XML to JSON |
 | `parse_csv` | Parse a CSV string and return the data as JSON |
 | `format_ndjson` | Validate and pretty-print newline-delimited JSON (NDJSON) |
+| `dedupe_ndjson` | Remove duplicate records from NDJSON, by exact match or by a key field |
 | `diff_env_example` | Diff a .env file against its .env.example template: flags keys missing from either side, plus empty placeholder values |
 | `parse_markdown_front_matter` | Split a Markdown document into its YAML front matter fields and body content |
 | `generate_markdown_toc` | Scan a Markdown document's ATX headings and build a nested table of contents with GitHub-style anchor slugs |

package/dist/index.js

@@ -4,7 +4,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { createHash } from "crypto";
+import { createHash, randomBytes } from "crypto";
 import * as yaml from "js-yaml";
 import {
   parseJson,
@@ -2606,6 +2606,53 @@ server.tool(
     return text(formatted);
   }
 );
+function _dedupeNdjsonMcp(input, keyField) {
+  const validated = _validateNdjson(input);
+  if (!validated.valid) {
+    const firstError = validated.lines.find((l) => !l.valid);
+    return { error: firstError ? `Line ${firstError.line}: ${firstError.error}` : "Invalid NDJSON" };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const keptRaw = [];
+  const removedLines = [];
+  for (const l of validated.lines) {
+    const parsed = JSON.parse(l.raw);
+    let key;
+    if (keyField) {
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed) || !(keyField in parsed)) {
+        return { error: `Line ${l.line}: missing key field "${keyField}"` };
+      }
+      key = JSON.stringify(parsed[keyField]);
+    } else {
+      key = JSON.stringify(parsed);
+    }
+    if (seen.has(key)) removedLines.push(l.line);
+    else {
+      seen.add(key);
+      keptRaw.push(l.raw.trim());
+    }
+  }
+  return {
+    totalLines: validated.totalLines,
+    uniqueLines: keptRaw.length,
+    duplicatesRemoved: removedLines.length,
+    output: keptRaw.join("\n"),
+    removedLines
+  };
+}
+server.tool(
+  "dedupe_ndjson",
+  "Remove duplicate records from NDJSON (newline-delimited JSON) input. With no keyField, two lines are duplicates when their parsed JSON values are structurally identical. With a keyField, two lines are duplicates when that field's value matches, keeping the first occurrence of each key.",
+  {
+    input: z.string().describe("NDJSON content: one JSON value per line"),
+    keyField: z.string().optional().describe("Optional field name to dedupe by instead of exact structural equality")
+  },
+  async ({ input, keyField }) => {
+    const result = _dedupeNdjsonMcp(input, keyField);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 function _decodePdfString(raw, isHex) {
   const bytes = [];
   if (isHex) {
@@ -4655,6 +4702,45 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _isMergePatchObjectMcp(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _mergeJsonPatchMcp(target, patch) {
+  if (!_isMergePatchObjectMcp(patch)) return patch;
+  const result = _isMergePatchObjectMcp(target) ? { ...target } : {};
+  for (const key of Object.keys(patch)) {
+    const value = patch[key];
+    if (value === null) {
+      delete result[key];
+    } else {
+      result[key] = _mergeJsonPatchMcp(result[key], value);
+    }
+  }
+  return result;
+}
+server.tool(
+  "apply_json_merge_patch",
+  "Apply an RFC 7396 JSON Merge Patch document to a target JSON document and return the merged result. A null-valued key in the patch removes that key from the target; a patch that is not itself a JSON object replaces the target wholesale, which is how arrays are replaced rather than merged element by element.",
+  {
+    target: z.string().describe("The target JSON document, as a JSON string"),
+    patch: z.string().describe("The RFC 7396 JSON Merge Patch document, as a JSON string")
+  },
+  async ({ target, patch }) => {
+    let targetParsed;
+    try {
+      targetParsed = JSON.parse(target);
+    } catch {
+      return errText({ error: "Target is not valid JSON" });
+    }
+    let patchParsed;
+    try {
+      patchParsed = JSON.parse(patch);
+    } catch {
+      return errText({ error: "Patch is not valid JSON" });
+    }
+    return text(JSON.stringify({ result: _mergeJsonPatchMcp(targetParsed, patchParsed) }, null, 2));
+  }
+);
 function _convertAprApyMcp(rate, compoundsPerYear, direction) {
   if (!Number.isFinite(rate) || rate < 0) return { error: "Rate must be zero or a positive number" };
   if (!Number.isInteger(compoundsPerYear) || compoundsPerYear <= 0) return { error: "Compounding frequency must be a positive whole number of periods per year" };
@@ -9406,6 +9492,132 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _PREFER_TOKEN_RE_MCP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+function _isPreferTokenMcp(s) {
+  return _PREFER_TOKEN_RE_MCP.test(s);
+}
+function _splitPreferTopLevelMcp(input, delim) {
+  const parts = [];
+  let current = "";
+  let inQuotes = false;
+  for (const ch of input) {
+    if (ch === '"') inQuotes = !inQuotes;
+    if (ch === delim && !inQuotes) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+function _parsePreferTokenValueMcp(part) {
+  const trimmed = part.trim();
+  if (!trimmed) return null;
+  const eq = trimmed.indexOf("=");
+  if (eq === -1) return { token: trimmed };
+  const token = trimmed.slice(0, eq).trim();
+  let value = trimmed.slice(eq + 1).trim();
+  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+  return { token, value };
+}
+function _formatPreferWordMcp(value) {
+  return _isPreferTokenMcp(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+function _formatPreferPreferencesMcp(preferences) {
+  return preferences.map((p) => {
+    let s = p.token;
+    if (p.value !== void 0) s += `=${_formatPreferWordMcp(p.value)}`;
+    for (const param of p.params ?? []) {
+      s += `;${param.name}`;
+      if (param.value !== void 0) s += `=${_formatPreferWordMcp(param.value)}`;
+    }
+    return s;
+  }).join(", ");
+}
+function _buildPreferHeaderMcp(preferences) {
+  if (!Array.isArray(preferences) || preferences.length === 0) {
+    return { error: "At least one preference is required" };
+  }
+  const built = [];
+  for (let i = 0; i < preferences.length; i++) {
+    const { token, value, params } = preferences[i];
+    if (typeof token !== "string" || !_isPreferTokenMcp(token.trim())) {
+      return { error: `preference ${i + 1}: token is required and must be a valid HTTP token` };
+    }
+    const cleanParams = [];
+    if (params !== void 0) {
+      if (!Array.isArray(params)) return { error: `preference ${i + 1}: params must be an array` };
+      for (const param of params) {
+        if (typeof param?.name !== "string" || !_isPreferTokenMcp(param.name.trim())) {
+          return { error: `preference ${i + 1}: parameter name is required and must be a valid HTTP token` };
+        }
+        cleanParams.push({ name: param.name.trim(), value: param.value !== void 0 ? String(param.value) : void 0 });
+      }
+    }
+    built.push({
+      token: token.trim(),
+      value: value !== void 0 ? String(value) : void 0,
+      params: cleanParams.length > 0 ? cleanParams : void 0
+    });
+  }
+  const headerValue = _formatPreferPreferencesMcp(built);
+  return { header: `Prefer: ${headerValue}`, headerValue, preferences: built };
+}
+function _parsePreferHeaderMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const withoutLabel = raw.trim().replace(/^prefer:\s*/i, "");
+  const parts = _splitPreferTopLevelMcp(withoutLabel, ",").map((p) => p.trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) return { error: "Input is empty" };
+  const preferences = [];
+  for (const part of parts) {
+    const segments = _splitPreferTopLevelMcp(part, ";").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (segments.length === 0) return { error: `Invalid preference: "${part}"` };
+    const main = _parsePreferTokenValueMcp(segments[0]);
+    if (!main || !_isPreferTokenMcp(main.token)) return { error: `Invalid preference token in "${part}"` };
+    const params = [];
+    for (const seg of segments.slice(1)) {
+      const p = _parsePreferTokenValueMcp(seg);
+      if (!p || !_isPreferTokenMcp(p.token)) return { error: `Invalid parameter in "${part}"` };
+      params.push({ name: p.token, value: p.value });
+    }
+    preferences.push({ token: main.token, value: main.value, params: params.length > 0 ? params : void 0 });
+  }
+  const headerValue = _formatPreferPreferencesMcp(preferences);
+  return { header: `Prefer: ${headerValue}`, headerValue, preferences };
+}
+server.tool(
+  "build_prefer_header",
+  "Build a Prefer request-header value from a list of preferences, each with an optional value and optional parameters, per RFC 7240. A value or parameter value that is not a valid HTTP token is quoted automatically.",
+  {
+    preferences: z.array(z.object({
+      token: z.string().describe('The preference token, e.g. "respond-async" or "return"'),
+      value: z.string().optional().describe("Optional value for the preference"),
+      params: z.array(z.object({
+        name: z.string(),
+        value: z.string().optional()
+      })).optional().describe("Optional parameters following the preference")
+    })).min(1).describe("Preferences to build the header from")
+  },
+  async ({ preferences }) => {
+    const result = _buildPreferHeaderMcp(preferences);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_prefer_header",
+  'Parse an existing Prefer header value (with or without a leading "Prefer:" label) into its list of preferences, each with an optional value and optional parameters, per RFC 7240.',
+  {
+    header: z.string().min(1).describe("The Prefer header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parsePreferHeaderMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 function _calculateBlendedLoanRateMcp(loans) {
   if (!Array.isArray(loans) || loans.length === 0) {
     return { error: "loans must be a non-empty array" };
@@ -9461,5 +9673,24 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+server.tool(
+  "generate_csp_nonce",
+  'Generate a cryptographically random, base64-encoded nonce for a Content-Security-Policy script-src or style-src directive, along with ready-to-paste header directive and <script>/<style nonce="..."> tag snippets. Generates a fresh, unique value on every call.',
+  {
+    byteLength: z.number().int().min(8).max(64).optional().describe("Number of random bytes to encode (default 16 = 128 bits, the CSP spec's recommended minimum)")
+  },
+  async ({ byteLength }) => {
+    const length = byteLength ?? 16;
+    const nonce = randomBytes(length).toString("base64");
+    return text(JSON.stringify({
+      nonce,
+      byteLength: length,
+      scriptSrcDirective: `script-src 'nonce-${nonce}'`,
+      styleSrcDirective: `style-src 'nonce-${nonce}'`,
+      scriptTag: `<script nonce="${nonce}">`,
+      styleTag: `<style nonce="${nonce}">`
+    }, null, 2));
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

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