@utilix-tech/mcp 0.64.0 → 0.66.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.66.0
+- Add `build_x_robots_tag`, `parse_x_robots_tag` tools: build an X-Robots-Tag response header from flag directives (noindex, nofollow, etc.) plus max-snippet/max-image-preview/max-video-preview/unavailable_after value directives, optionally scoped to a crawler user-agent, or parse an existing header into the same shape.
+- Add `lookup_websocket_opcode`, `list_websocket_opcodes` tools: look up what a WebSocket frame opcode means per RFC 6455's 4-bit opcode space, or list every opcode.
+
+## 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 227 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 (44 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
@@ -248,6 +248,12 @@ 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 |
+| `build_x_robots_tag` | Build an X-Robots-Tag response header from directives (noindex, nofollow, max-snippet, etc.), optionally scoped to a crawler user-agent |
+| `parse_x_robots_tag` | Parse an existing X-Robots-Tag header value into the same shape |
+| `lookup_websocket_opcode` | Look up what a WebSocket frame opcode means, per RFC 6455's 4-bit opcode space |
+| `list_websocket_opcodes` | List every WebSocket frame opcode (0x0-0xF) |
 
 ### Color (4 tools)
 | Tool | Description |
@@ -277,7 +283,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 +301,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,288 @@ 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 _X_ROBOTS_TAG_FLAGS_MCP = /* @__PURE__ */ new Set(["noindex", "nofollow", "noarchive", "nosnippet", "notranslate", "noimageindex", "none", "all", "indexifembedded"]);
+var _X_ROBOTS_TAG_FLAG_NOTES_MCP = {
+  noindex: "Do not show this page in search results.",
+  nofollow: "Do not follow, or pass ranking credit through, any links on this page.",
+  noarchive: "Do not show a cached copy of this page in search results.",
+  nosnippet: "Do not show a text snippet or video preview for this page in search results.",
+  notranslate: "Do not offer a translation of this page in search results.",
+  noimageindex: "Do not index images on this page.",
+  none: "Shorthand for noindex plus nofollow combined.",
+  all: "Explicitly allow indexing and following, the default with no directives at all.",
+  indexifembedded: "Allow indexing of this page's content when embedded via iframe in another page, even if this page also carries noindex. Only Google supports this directive."
+};
+var _X_ROBOTS_TAG_VALUED_DIRECTIVES_MCP = /* @__PURE__ */ new Set(["max-snippet", "max-image-preview", "max-video-preview", "unavailable_after"]);
+function _isXRobotsTagFlagMcp(value) {
+  return _X_ROBOTS_TAG_FLAGS_MCP.has(value);
+}
+function _buildXRobotsTagMcp(options) {
+  const { flags = [], maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, userAgent } = options;
+  for (const flag of flags) {
+    if (!_isXRobotsTagFlagMcp(flag)) return { error: `Unknown directive "${flag}"` };
+  }
+  if (maxSnippet !== void 0 && (!Number.isInteger(maxSnippet) || maxSnippet < -1)) return { error: "maxSnippet must be an integer >= -1" };
+  if (maxVideoPreview !== void 0 && (!Number.isInteger(maxVideoPreview) || maxVideoPreview < -1)) return { error: "maxVideoPreview must be an integer >= -1" };
+  if (maxImagePreview !== void 0 && !["none", "standard", "large"].includes(maxImagePreview)) return { error: 'maxImagePreview must be one of "none", "standard", "large"' };
+  if (unavailableAfter !== void 0 && (unavailableAfter.trim() === "" || Number.isNaN(Date.parse(unavailableAfter)))) return { error: "unavailableAfter must be a valid, parseable date string" };
+  const uniqueFlags = Array.from(new Set(flags));
+  if (uniqueFlags.length === 0 && maxSnippet === void 0 && maxImagePreview === void 0 && maxVideoPreview === void 0 && unavailableAfter === void 0) {
+    return { error: "At least one directive is required" };
+  }
+  const warnings = [];
+  if (uniqueFlags.includes("none") && (uniqueFlags.includes("noindex") || uniqueFlags.includes("nofollow"))) {
+    warnings.push('"none" already implies noindex and nofollow; combining it with either is redundant.');
+  }
+  if (uniqueFlags.includes("all") && uniqueFlags.some((f) => f !== "all" && f !== "indexifembedded")) {
+    warnings.push('"all" explicitly allows indexing and following, which contradicts any restrictive directive combined with it.');
+  }
+  const directives = [...uniqueFlags];
+  const notes = uniqueFlags.map((f) => `${f}: ${_X_ROBOTS_TAG_FLAG_NOTES_MCP[f]}`);
+  if (maxSnippet !== void 0) {
+    directives.push(`max-snippet: ${maxSnippet}`);
+    notes.push(`max-snippet: ${maxSnippet === 0 ? "Show no text snippet at all." : maxSnippet === -1 ? "No limit on snippet length." : `Limit the text snippet to at most ${maxSnippet} characters.`}`);
+  }
+  if (maxImagePreview !== void 0) {
+    directives.push(`max-image-preview: ${maxImagePreview}`);
+    notes.push(`max-image-preview: Limit any image preview shown in search results to the "${maxImagePreview}" size.`);
+  }
+  if (maxVideoPreview !== void 0) {
+    directives.push(`max-video-preview: ${maxVideoPreview}`);
+    notes.push(`max-video-preview: ${maxVideoPreview === 0 ? "Show no video preview at all, a static image only." : maxVideoPreview === -1 ? "No limit on video preview length." : `Limit the video preview to at most ${maxVideoPreview} seconds.`}`);
+  }
+  if (unavailableAfter !== void 0) {
+    directives.push(`unavailable_after: ${unavailableAfter}`);
+    notes.push("unavailable_after: Stop showing this page in search results after this date.");
+  }
+  const directivesJoined = directives.join(", ");
+  const header = userAgent ? `${userAgent}: ${directivesJoined}` : directivesJoined;
+  return { header, headerName: "X-Robots-Tag", snippet: `X-Robots-Tag: ${header}`, directives, notes, warnings };
+}
+function _parseXRobotsTagMcp(raw) {
+  if (!raw || raw.trim() === "") return { error: "Input is empty" };
+  let withoutLabel = raw.trim().replace(/^x-robots-tag:\s*/i, "");
+  let userAgent;
+  const firstColon = withoutLabel.indexOf(":");
+  const firstComma = withoutLabel.indexOf(",");
+  if (firstColon !== -1 && (firstComma === -1 || firstColon < firstComma)) {
+    const candidate = withoutLabel.slice(0, firstColon).trim();
+    const candidateLower = candidate.toLowerCase();
+    if (candidate !== "" && !_X_ROBOTS_TAG_VALUED_DIRECTIVES_MCP.has(candidateLower) && !_isXRobotsTagFlagMcp(candidateLower)) {
+      userAgent = candidate;
+      withoutLabel = withoutLabel.slice(firstColon + 1).trim();
+    }
+  }
+  const tokens = withoutLabel.split(",").map((t) => t.trim()).filter((t) => t !== "");
+  if (tokens.length === 0) return { error: "No directives found" };
+  const flags = [];
+  let maxSnippet;
+  let maxImagePreview;
+  let maxVideoPreview;
+  let unavailableAfter;
+  for (const token of tokens) {
+    const eq = token.indexOf(":");
+    const name = (eq === -1 ? token : token.slice(0, eq)).trim().toLowerCase();
+    const value = eq === -1 ? "" : token.slice(eq + 1).trim();
+    if (eq === -1) {
+      if (!_isXRobotsTagFlagMcp(name)) return { error: `Unrecognized directive "${token}"` };
+      flags.push(name);
+      continue;
+    }
+    if (name === "max-snippet") {
+      const n = Number(value);
+      if (value === "" || !Number.isInteger(n) || n < -1) return { error: `max-snippet value "${value}" is not a valid integer >= -1` };
+      maxSnippet = n;
+    } else if (name === "max-image-preview") {
+      if (!["none", "standard", "large"].includes(value)) return { error: `max-image-preview value "${value}" must be one of "none", "standard", "large"` };
+      maxImagePreview = value;
+    } else if (name === "max-video-preview") {
+      const n = Number(value);
+      if (value === "" || !Number.isInteger(n) || n < -1) return { error: `max-video-preview value "${value}" is not a valid integer >= -1` };
+      maxVideoPreview = n;
+    } else if (name === "unavailable_after") {
+      if (value === "" || Number.isNaN(Date.parse(value))) return { error: `unavailable_after value "${value}" is not a valid, parseable date` };
+      unavailableAfter = value;
+    } else {
+      return { error: `Unrecognized directive "${token}"` };
+    }
+  }
+  return _buildXRobotsTagMcp({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, userAgent });
+}
+server.tool(
+  "build_x_robots_tag",
+  `Build an X-Robots-Tag response-header value from flag directives (noindex, nofollow, noarchive, nosnippet, notranslate, noimageindex, none, all, indexifembedded) plus optional max-snippet, max-image-preview, max-video-preview, and unavailable_after value directives, per Google's documented robots directive syntax. Optionally scope the header to a single crawler with userAgent (e.g. "googlebot").`,
+  {
+    flags: z.array(z.enum(["noindex", "nofollow", "noarchive", "nosnippet", "notranslate", "noimageindex", "none", "all", "indexifembedded"])).optional().describe("Flag directives to include"),
+    maxSnippet: z.number().int().min(-1).optional().describe("Max text snippet length in characters; 0 shows no snippet, -1 means no limit"),
+    maxImagePreview: z.enum(["none", "standard", "large"]).optional().describe("Max image preview size shown in search results"),
+    maxVideoPreview: z.number().int().min(-1).optional().describe("Max video preview length in seconds; 0 shows no preview, -1 means no limit"),
+    unavailableAfter: z.string().optional().describe("Stop showing this page in search results after this date/time"),
+    userAgent: z.string().optional().describe('Optional crawler name to scope the header to, e.g. "googlebot"')
+  },
+  async ({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, userAgent }) => {
+    const result = _buildXRobotsTagMcp({ flags, maxSnippet, maxImagePreview, maxVideoPreview, unavailableAfter, userAgent });
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "parse_x_robots_tag",
+  'Parse an existing X-Robots-Tag header value (with or without a leading "X-Robots-Tag:" label, and with or without a leading crawler user-agent token) into the same shape build_x_robots_tag returns.',
+  {
+    header: z.string().min(1).describe("The X-Robots-Tag header value to parse")
+  },
+  async ({ header }) => {
+    const result = _parseXRobotsTagMcp(header);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+var _WELL_KNOWN_OPCODES_MCP = {
+  0: { name: "Continuation Frame", description: "Continues a fragmented message whose first frame was a text or binary frame sent with the FIN bit unset.", category: "data" },
+  1: { name: "Text Frame", description: "Carries a UTF-8 encoded text payload.", category: "data" },
+  2: { name: "Binary Frame", description: "Carries an arbitrary binary payload.", category: "data" },
+  8: { name: "Connection Close", description: "Initiates or acknowledges closing the connection, optionally carrying a 2-byte close code and a UTF-8 reason in its payload.", category: "control" },
+  9: { name: "Ping", description: "A control frame used to check the connection is alive; the receiver should reply with a Pong carrying the same application data.", category: "control" },
+  10: { name: "Pong", description: "Sent in response to a Ping (or unprompted as a heartbeat), carrying the same application data as the Ping it answers.", category: "control" }
+};
+var _RESERVED_NON_CONTROL_OPCODES_MCP = /* @__PURE__ */ new Set([3, 4, 5, 6, 7]);
+function _describeOpcodeMcp(opcode) {
+  const known = _WELL_KNOWN_OPCODES_MCP[opcode];
+  const hex = `0x${opcode.toString(16).toUpperCase()}`;
+  if (known) return { opcode, hex, name: known.name, description: known.description, category: known.category, isControl: known.category === "control" };
+  if (_RESERVED_NON_CONTROL_OPCODES_MCP.has(opcode)) {
+    return { opcode, hex, name: "Reserved (non-control)", description: "Reserved for future non-control frame types by a later revision of the WebSocket protocol. No meaning is defined yet; a compliant endpoint must fail the connection if it receives one.", category: "reserved-non-control", isControl: false };
+  }
+  return { opcode, hex, name: "Reserved (control)", description: "Reserved for future control frame types by a later revision of the WebSocket protocol. No meaning is defined yet; a compliant endpoint must fail the connection if it receives one.", category: "reserved-control", isControl: true };
+}
+server.tool(
+  "lookup_websocket_opcode",
+  "Look up what a WebSocket frame opcode means per RFC 6455: 0x0-0x2 are data frames (continuation, text, binary), 0x8-0xA are control frames (close, ping, pong), and the rest of the 4-bit opcode space is reserved for future protocol revisions.",
+  {
+    opcode: z.number().int().min(0).max(15).describe("The WebSocket frame opcode to look up (0-15 / 0x0-0xF)")
+  },
+  async ({ opcode }) => {
+    const result = _describeOpcodeMcp(opcode);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "list_websocket_opcodes",
+  "List every WebSocket frame opcode (0x0-0xF), the full 4-bit opcode space defined by RFC 6455, in ascending order.",
+  {},
+  async () => {
+    const opcodes = [];
+    for (let opcode = 0; opcode <= 15; opcode++) opcodes.push(_describeOpcodeMcp(opcode));
+    return text(JSON.stringify({ opcodes }, 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.66.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",