@utilix-tech/mcp 0.64.0 → 0.65.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 220 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.
 
@@ -205,7 +205,7 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 (38 tools)
+### API / Network (40 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -248,6 +248,8 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `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 |
@@ -277,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 |
@@ -295,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.64.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",