@utilix-tech/mcp 0.63.0 → 0.65.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.65.0
+- Add `build_hsts_header`, `parse_hsts_header` tools: build a Strict-Transport-Security response header from a max-age plus includeSubDomains/preload flags, flagging combinations that won't qualify for browser HSTS preload lists, or parse an existing header into the same shape.
+- Add `align_markdown_tables` tool: reformat every GitHub-Flavored-Markdown pipe table in a document so each column's pipes line up visually, preserving left/center/right alignment markers and skipping tables inside fenced code blocks.
+
+## 0.64.0
+- Add `calculate_loan_refinance` tool: compare a current loan's remaining payments against a new refinanced loan on the same outstanding balance, and compute the monthly savings and the break-even month where cumulative savings recoup the closing costs.
+- Add `parse_multipart_form_data` tool: parse a raw multipart/form-data request body into its individual parts (field name, filename, headers, decoded value) per RFC 7578, with an optional Content-Type header value to extract the boundary from.
+
 ## 0.63.0
 - Add `plan_debt_payoff` tool: simulate paying off a list of debts under both the snowball (smallest balance first) and avalanche (highest rate first) strategies given a fixed extra monthly payment, and compare months to payoff and total interest.
 - Add `audit_dependency_ranges` tool: classify each dependency's version specifier range type and flag wildcard ranges, the "latest" tag, git/URL/file/link dependencies, and packages listed with conflicting or redundant ranges across sections.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 218 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 223 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.
 
@@ -162,7 +162,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `convert_timezone` | Convert a date/time between timezones |
 | `convert_iso8601_duration` | Parse an ISO 8601 duration into components and total seconds, or format seconds into a duration string |
 
-### Units (38 tools)
+### Units (39 tools)
 | Tool | Description |
 |------|-------------|
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
@@ -203,8 +203,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_freelancer_rate` | Solve for the minimum hourly rate a freelancer must charge to hit a target annual income, given billable hours, weeks worked, overhead, and a profit margin |
 | `calculate_extra_payment_payoff` | Compute how much faster a fixed-rate loan pays off, and how much interest is saved, when a fixed extra amount is added to every monthly payment |
 | `plan_debt_payoff` | Simulate paying off a list of debts under both the snowball (smallest balance first) and avalanche (highest rate first) strategies given a fixed extra monthly payment, and compare months to payoff and total interest |
+| `calculate_loan_refinance` | Compare a current loan's remaining payments against a new refinanced loan on the same outstanding balance, and compute the monthly savings and the break-even month where cumulative savings recoup the closing costs |
 
-### API / Network (37 tools)
+### API / Network (40 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -246,6 +247,9 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `parse_priority_header` | Parse an existing Priority header value into its urgency and incremental fields, with spec defaults applied |
 | `lookup_close_code` | Look up what a WebSocket close code means, per RFC 6455 and the IANA reserved ranges |
 | `list_close_codes` | List every well-known WebSocket close code (1000-1015) |
+| `parse_multipart_form_data` | Parse a raw multipart/form-data request body into its individual parts: field name, filename, headers, and decoded value, per RFC 7578 |
+| `build_hsts_header` | Build a Strict-Transport-Security response header from a max-age plus includeSubDomains/preload flags, flagging combinations that won't qualify for browser HSTS preload lists |
+| `parse_hsts_header` | Parse an existing Strict-Transport-Security header value into the same shape, with preload-list eligibility flagged |
 
 ### Color (4 tools)
 | Tool | Description |
@@ -275,7 +279,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `validate_package_exports` | Validate a package.json "exports" field: dual-package (ESM/CJS) misconfigurations like a missing default fallback or a require/import pointing at the wrong extension |
 | `audit_dependency_ranges` | Classify each package.json dependency's version range type and flag wildcard ranges, the "latest" tag, git/URL/file/link dependencies, and packages listed with conflicting or redundant ranges across sections |
 
-### Data (14 tools)
+### Data (16 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
@@ -293,6 +297,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `calculate_markdown_task_list_progress` | Parse a Markdown document's checkbox task list and report completion percentage overall and per section, grouped by the nearest preceding heading |
 | `analyze_caption_speed` | Parse an SRT or WebVTT file and report the words-per-minute reading speed of every cue, flagging ones that exceed common broadcast accessibility guidelines |
 | `infer_csv_column_types` | Parse CSV/TSV data and infer each column's data type (integer, float, boolean, ISO 8601 date, or string), flagging nullable columns and empty-cell counts |
+| `align_markdown_tables` | Reformat every GitHub-Flavored-Markdown pipe table in a document so each column's pipes line up visually, preserving left/center/right alignment markers |
 
 ### CSS (2 tools)
 | Tool | Description |

package/dist/index.js

@@ -6120,6 +6120,153 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+var _MD_TABLE_DELIM_CELL_RE_MCP = /^:?-+:?$/;
+function _splitMarkdownTableRowMcp(line) {
+  const raw = [];
+  let current = "";
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "\\" && line[i + 1] === "|") {
+      current += "\\|";
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      raw.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  raw.push(current);
+  const cells = raw.map((c) => c.trim());
+  if (cells.length > 1 && cells[0] === "") cells.shift();
+  if (cells.length > 1 && cells[cells.length - 1] === "") cells.pop();
+  return cells;
+}
+function _isMarkdownTableDelimiterRowMcp(line) {
+  const trimmed = line.trim();
+  if (trimmed === "" || !trimmed.includes("-")) return false;
+  const cells = _splitMarkdownTableRowMcp(trimmed);
+  if (cells.length === 0) return false;
+  return cells.every((c) => _MD_TABLE_DELIM_CELL_RE_MCP.test(c));
+}
+function _markdownTableCellAlignmentMcp(delimCell) {
+  const left = delimCell.startsWith(":");
+  const right = delimCell.endsWith(":");
+  if (left && right) return "center";
+  if (right) return "right";
+  if (left) return "left";
+  return "none";
+}
+function _padMarkdownTableCellMcp(text2, width, alignment) {
+  const diff = Math.max(0, width - [...text2].length);
+  if (alignment === "right") return " ".repeat(diff) + text2;
+  if (alignment === "center") {
+    const left = Math.floor(diff / 2);
+    const right = diff - left;
+    return " ".repeat(left) + text2 + " ".repeat(right);
+  }
+  return text2 + " ".repeat(diff);
+}
+function _markdownTableDelimiterCellMcp(width, alignment) {
+  switch (alignment) {
+    case "left":
+      return ":" + "-".repeat(Math.max(1, width - 1));
+    case "right":
+      return "-".repeat(Math.max(1, width - 1)) + ":";
+    case "center":
+      return ":" + "-".repeat(Math.max(1, width - 2)) + ":";
+    default:
+      return "-".repeat(width);
+  }
+}
+function _alignMarkdownTablesMcp(markdown) {
+  if (typeof markdown !== "string") return { error: "markdown must be a string" };
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const outputLines = [...lines];
+  const tables = [];
+  const warnings = [];
+  let inFence = false;
+  let fenceMarker = "";
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1][0];
+      } else if (fenceMatch[1][0] === fenceMarker) {
+        inFence = false;
+      }
+      i++;
+      continue;
+    }
+    if (inFence) {
+      i++;
+      continue;
+    }
+    const nextLine = lines[i + 1];
+    if (line.includes("|") && nextLine !== void 0 && _isMarkdownTableDelimiterRowMcp(nextLine)) {
+      const headerCells = _splitMarkdownTableRowMcp(line);
+      const delimCells = _splitMarkdownTableRowMcp(nextLine);
+      if (headerCells.length > 0 && headerCells.length === delimCells.length) {
+        const columnCount = headerCells.length;
+        const alignments = delimCells.map(_markdownTableCellAlignmentMcp);
+        let j = i + 2;
+        const bodyRows = [];
+        while (j < lines.length && lines[j].trim() !== "" && lines[j].includes("|")) {
+          bodyRows.push(_splitMarkdownTableRowMcp(lines[j]));
+          j++;
+        }
+        const normalizedBody = [];
+        for (const row of bodyRows) {
+          if (row.length !== columnCount) {
+            warnings.push(`Table at line ${i + 1}: a row has ${row.length} cell(s) but the header has ${columnCount}; it was padded/truncated to match.`);
+          }
+          normalizedBody.push(Array.from({ length: columnCount }, (_, c) => row[c] ?? ""));
+        }
+        const allRows = [headerCells, ...normalizedBody];
+        const widths = Array.from(
+          { length: columnCount },
+          (_, c) => Math.max(3, ...allRows.map((r) => [...r[c] ?? ""].length))
+        );
+        const formattedHeader = "| " + headerCells.map((c, idx) => _padMarkdownTableCellMcp(c, widths[idx], alignments[idx])).join(" | ") + " |";
+        const formattedDelim = "| " + widths.map((w, idx) => _markdownTableDelimiterCellMcp(w, alignments[idx])).join(" | ") + " |";
+        const formattedBody = normalizedBody.map((row) => "| " + row.map((c, idx) => _padMarkdownTableCellMcp(c, widths[idx], alignments[idx])).join(" | ") + " |");
+        const formattedLines = [formattedHeader, formattedDelim, ...formattedBody];
+        for (let k = 0; k < formattedLines.length; k++) {
+          outputLines[i + k] = formattedLines[k];
+        }
+        tables.push({
+          startLine: i + 1,
+          endLine: i + formattedLines.length,
+          columnCount,
+          rowCount: normalizedBody.length,
+          alignments
+        });
+        i = j;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (tables.length === 0) return { error: "No Markdown tables found" };
+  return { output: outputLines.join("\n"), tables, warnings };
+}
+server.tool(
+  "align_markdown_tables",
+  "Reformat every GitHub-Flavored-Markdown pipe table in a document so each column's pipes line up visually, padding cells to the widest content in that column and rebuilding the delimiter row to match, while preserving each column's declared alignment. Tables inside fenced code blocks are left untouched.",
+  {
+    markdown: z.string().describe("The Markdown document containing one or more pipe tables")
+  },
+  async ({ markdown }) => {
+    const result = _alignMarkdownTablesMcp(markdown);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _COMMIT_DEFAULT_TYPES_MCP = ["build", "chore", "ci", "docs", "feat", "fix", "perf", "refactor", "revert", "style", "test"];
 var _COMMIT_HEADER_RE_MCP = /^([A-Za-z][A-Za-z0-9-]*)(\(([^()]*)\))?(!)?: (.+)$/;
 var _COMMIT_FOOTER_LINE_RE_MCP = /^([A-Za-z][A-Za-z0-9-]*|BREAKING CHANGE)(: ?| #)(.*)$/;
@@ -9968,6 +10115,112 @@ server.tool(
     return text(JSON.stringify({ codes }, null, 2));
   }
 );
+var _HSTS_ONE_YEAR_SECONDS_MCP = 31536e3;
+function _humanizeHstsMaxAgeMcp(seconds) {
+  if (seconds === 0) return "0 seconds (clears HSTS)";
+  if (seconds % _HSTS_ONE_YEAR_SECONDS_MCP === 0) {
+    const years = seconds / _HSTS_ONE_YEAR_SECONDS_MCP;
+    return `${years} year${years === 1 ? "" : "s"}`;
+  }
+  if (seconds % 86400 === 0) {
+    const days = seconds / 86400;
+    return `${days} day${days === 1 ? "" : "s"}`;
+  }
+  if (seconds % 3600 === 0) {
+    const hours = seconds / 3600;
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
+  }
+  return `${seconds} second${seconds === 1 ? "" : "s"}`;
+}
+function _buildHstsMcp(options) {
+  const { maxAge, includeSubDomains = false, preload = false } = options;
+  if (!Number.isInteger(maxAge) || maxAge < 0) {
+    return { error: "maxAge must be a non-negative integer number of seconds" };
+  }
+  const warnings = [];
+  const preloadEligible = maxAge >= _HSTS_ONE_YEAR_SECONDS_MCP && includeSubDomains && preload;
+  if (preload && !includeSubDomains) {
+    warnings.push("Browser HSTS preload lists require includeSubDomains whenever preload is set; this header will not qualify for preloading as configured.");
+  }
+  if (preload && maxAge < _HSTS_ONE_YEAR_SECONDS_MCP) {
+    warnings.push(`Browser HSTS preload lists require max-age of at least ${_HSTS_ONE_YEAR_SECONDS_MCP} (1 year); ${maxAge} is too low to qualify.`);
+  }
+  if (maxAge === 0) {
+    warnings.push("max-age=0 tells the browser to forget this host supports HSTS immediately, this clears HSTS rather than enabling it.");
+  } else if (maxAge < 86400) {
+    warnings.push("A max-age under a day gives very little protection; most real deployments use at least 15552000 (180 days) once confident HTTPS is fully working.");
+  }
+  const parts = [`max-age=${maxAge}`];
+  if (includeSubDomains) parts.push("includeSubDomains");
+  if (preload) parts.push("preload");
+  const header = parts.join("; ");
+  return {
+    header,
+    headerName: "Strict-Transport-Security",
+    snippet: `Strict-Transport-Security: ${header}`,
+    maxAge,
+    maxAgeHuman: _humanizeHstsMaxAgeMcp(maxAge),
+    includeSubDomains,
+    preload,
+    preloadEligible,
+    warnings
+  };
+}
+function _parseHstsMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  const withoutLabel = raw.trim().replace(/^strict-transport-security:\s*/i, "");
+  const tokens = withoutLabel.split(";").map((t) => t.trim()).filter((t) => t !== "");
+  if (tokens.length === 0) return { error: "No directives found" };
+  let maxAge = null;
+  let includeSubDomains = false;
+  let preload = false;
+  for (const token of tokens) {
+    const eq = token.indexOf("=");
+    const name = (eq === -1 ? token : token.slice(0, eq)).trim().toLowerCase();
+    if (name === "max-age") {
+      const rawValue = eq === -1 ? "" : token.slice(eq + 1).trim();
+      const n = Number(rawValue);
+      if (rawValue === "" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) {
+        return { error: `max-age value "${rawValue}" is not a valid non-negative integer` };
+      }
+      maxAge = n;
+    } else if (name === "includesubdomains") {
+      includeSubDomains = true;
+    } else if (name === "preload") {
+      preload = true;
+    } else {
+      return { error: `Unrecognized directive "${token}"` };
+    }
+  }
+  if (maxAge === null) return { error: "max-age directive is required" };
+  return _buildHstsMcp({ maxAge, includeSubDomains, preload });
+}
+server.tool(
+  "build_hsts_header",
+  "Build a Strict-Transport-Security response-header value from a max-age (in seconds) plus optional includeSubDomains and preload directives, flagging combinations that will not qualify for browser HSTS preload lists (which require max-age >= 1 year, includeSubDomains, and preload all together).",
+  {
+    maxAge: z.number().int().min(0).describe("How long, in seconds, the browser should remember this host is HTTPS-only, e.g. 31536000 for 1 year"),
+    includeSubDomains: z.boolean().optional().describe("Whether the policy also applies to all subdomains, default false"),
+    preload: z.boolean().optional().describe("Whether to opt into browser HSTS preload lists, default false")
+  },
+  async ({ maxAge, includeSubDomains, preload }) => {
+    const result = _buildHstsMcp({ maxAge, includeSubDomains, preload });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_hsts_header",
+  'Parse an existing Strict-Transport-Security header value (with or without a leading "Strict-Transport-Security:" label) into its max-age, includeSubDomains, and preload fields, flagging whether it qualifies for browser HSTS preload lists.',
+  {
+    header: z.string().min(1).describe("The Strict-Transport-Security header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parseHstsMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
 var _DEBT_PAYOFF_MAX_MONTHS_MCP = 1200;
 function _simulateDebtPayoffMcp(debts, order, extraMonthlyPayment) {
   const round2 = (n) => Math.round(n * 100) / 100;
@@ -10187,5 +10440,140 @@ server.tool(
     return text(JSON.stringify(result, null, 2));
   }
 );
+function _calculateLoanForRefinanceMcp(principal, annualRatePercent, termMonths) {
+  if (!Number.isFinite(principal) || principal <= 0) return { error: "Principal must be a positive number" };
+  if (!Number.isFinite(annualRatePercent) || annualRatePercent < 0) {
+    return { error: "Annual interest rate must be zero or a positive number" };
+  }
+  if (!Number.isInteger(termMonths) || termMonths <= 0) {
+    return { error: "Term must be a positive whole number of months" };
+  }
+  const monthlyRate = annualRatePercent / 100 / 12;
+  let monthlyPayment;
+  if (monthlyRate === 0) {
+    monthlyPayment = principal / termMonths;
+  } else {
+    const factor = Math.pow(1 + monthlyRate, termMonths);
+    monthlyPayment = principal * monthlyRate * factor / (factor - 1);
+  }
+  let balance = _roundMoneyMcp(principal);
+  let totalPayment = 0;
+  for (let month = 1; month <= termMonths; month++) {
+    const interest = monthlyRate === 0 ? 0 : _roundMoneyMcp(balance * monthlyRate);
+    let principalPortion = _roundMoneyMcp(monthlyPayment) - interest;
+    if (month === termMonths || principalPortion > balance) principalPortion = balance;
+    const payment = _roundMoneyMcp(principalPortion + interest);
+    balance = _roundMoneyMcp(balance - principalPortion);
+    totalPayment += payment;
+  }
+  return {
+    monthlyPayment: _roundMoneyMcp(monthlyPayment),
+    totalPayment: _roundMoneyMcp(totalPayment),
+    totalInterest: _roundMoneyMcp(totalPayment - principal),
+    termMonths
+  };
+}
+function _calculateLoanRefinanceMcp(currentBalance, currentRatePercent, currentRemainingMonths, newRatePercent, newTermMonths, closingCosts) {
+  const current = _calculateLoanForRefinanceMcp(currentBalance, currentRatePercent, currentRemainingMonths);
+  if ("error" in current) return current;
+  const refinanced = _calculateLoanForRefinanceMcp(currentBalance, newRatePercent, newTermMonths);
+  if ("error" in refinanced) return refinanced;
+  if (!Number.isFinite(closingCosts) || closingCosts < 0) {
+    return { error: "Closing costs must be zero or a positive number" };
+  }
+  const monthlySavings = _roundMoneyMcp(current.monthlyPayment - refinanced.monthlyPayment);
+  const breakEvenMonths = monthlySavings > 0 ? Math.ceil(closingCosts / monthlySavings) : null;
+  return {
+    currentMonthlyPayment: current.monthlyPayment,
+    newMonthlyPayment: refinanced.monthlyPayment,
+    monthlySavings,
+    closingCosts: _roundMoneyMcp(closingCosts),
+    breakEvenMonths,
+    currentTotalInterest: current.totalInterest,
+    newTotalInterest: refinanced.totalInterest,
+    totalInterestSavings: _roundMoneyMcp(current.totalInterest - refinanced.totalInterest)
+  };
+}
+server.tool(
+  "calculate_loan_refinance",
+  "Compare a current loan's remaining payments against a new refinanced loan on the same outstanding balance, and compute the monthly savings and the break-even month where cumulative monthly savings recoup the closing costs.",
+  {
+    currentBalance: z.number().describe("Outstanding balance on the current loan"),
+    currentRatePercent: z.number().describe("Current loan's annual interest rate as a percent, e.g. 6.5"),
+    currentRemainingMonths: z.number().int().describe("Months remaining on the current loan"),
+    newRatePercent: z.number().describe("New (refinanced) loan's annual interest rate as a percent, e.g. 5.5"),
+    newTermMonths: z.number().int().describe("New loan's term in months"),
+    closingCosts: z.number().describe("Total closing costs to refinance")
+  },
+  async ({ currentBalance, currentRatePercent, currentRemainingMonths, newRatePercent, newTermMonths, closingCosts }) => {
+    const result = _calculateLoanRefinanceMcp(currentBalance, currentRatePercent, currentRemainingMonths, newRatePercent, newTermMonths, closingCosts);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+function _extractMultipartBoundaryMcp(contentType) {
+  if (!contentType) return null;
+  const match = contentType.match(/boundary=(?:"([^"]*)"|([^;\s]+))/i);
+  if (!match) return null;
+  return match[1] ?? match[2] ?? null;
+}
+function _parseMultipartFormDataMcp(body, boundary) {
+  if (!body || !body.trim()) return { error: "Body is empty" };
+  if (!boundary || !boundary.trim()) return { error: "Boundary is required" };
+  const normalized = body.replace(/\r\n/g, "\n");
+  const delimiter = `--${boundary}`;
+  const segments = normalized.split(delimiter);
+  if (segments.length < 3) {
+    return { error: `No parts found for boundary "${boundary}"; check that it matches the boundary used in the body` };
+  }
+  const parts = [];
+  for (let i = 1; i < segments.length; i++) {
+    let segment = segments[i];
+    if (segment.startsWith("--")) break;
+    segment = segment.replace(/^\n/, "").replace(/\n$/, "");
+    const headerEnd = segment.indexOf("\n\n");
+    if (headerEnd === -1) continue;
+    const headerBlock = segment.slice(0, headerEnd);
+    const value = segment.slice(headerEnd + 2);
+    const headers = {};
+    for (const line of headerBlock.split("\n")) {
+      const colon = line.indexOf(":");
+      if (colon === -1) continue;
+      headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+    }
+    const disposition = headers["content-disposition"] ?? "";
+    const nameMatch = disposition.match(/name="([^"]*)"/);
+    const filenameMatch = disposition.match(/filename="([^"]*)"/);
+    const partContentType = headers["content-type"] ?? "";
+    const isBinary = !!filenameMatch && !partContentType.startsWith("text/") && !partContentType.includes("json") && !partContentType.includes("xml");
+    parts.push({
+      name: nameMatch ? nameMatch[1] : null,
+      filename: filenameMatch ? filenameMatch[1] : null,
+      headers,
+      value,
+      isBinary
+    });
+  }
+  if (parts.length === 0) {
+    return { error: `No parts found for boundary "${boundary}"; check that it matches the boundary used in the body` };
+  }
+  return { boundary, parts };
+}
+server.tool(
+  "parse_multipart_form_data",
+  "Parse a raw multipart/form-data request body into its individual parts: field name, filename (for file fields), headers, and decoded value, per RFC 7578. Give the boundary directly, or the request's Content-Type header value to extract it from automatically.",
+  {
+    body: z.string().min(1).describe("The raw multipart/form-data request body"),
+    boundary: z.string().optional().describe("The multipart boundary (without the leading --), if known directly"),
+    contentType: z.string().optional().describe("Alternative to boundary: the request's Content-Type header value, from which the boundary is extracted")
+  },
+  async ({ body, boundary, contentType }) => {
+    const resolvedBoundary = boundary ?? (contentType ? _extractMultipartBoundaryMcp(contentType) : null);
+    if (!resolvedBoundary) return errText({ error: "boundary is required (either directly, or via a contentType header containing a boundary parameter)" });
+    const result = _parseMultipartFormDataMcp(body, resolvedBoundary);
+    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.63.0",
+  "version": "0.65.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",