@utilix-tech/mcp 0.4.1 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 97 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 101 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.
 
@@ -150,13 +150,15 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `convert_bytes` | Convert between B, KB, MB, GB, TB, KiB, MiB, GiB, TiB |
 | `px_to_units` | Convert pixels to rem, em, pt, and vw |
 
-### API / Network (4 tools)
+### API / Network (6 tools)
 | Tool | Description |
 |------|-------------|
 | `decode_jwt` | Decode a JWT: header, payload, and expiry |
+| `parse_jwks` | Parse a JWKS (or a single bare JWK): type, use, algorithm, key ID, and size per key |
 | `build_curl` | Build a cURL command from method, URL, headers, and body |
 | `curl_to_code` | Convert a cURL command to fetch, axios, Python, Go, PHP, or Ruby |
 | `cors_headers` | Generate CORS response headers for a configuration |
+| `parse_har` | Parse a DevTools .har network export into requests and summary stats |
 
 ### Color (4 tools)
 | Tool | Description |
@@ -177,13 +179,14 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `parse_env` | Parse a .env file and return all key-value pairs |
 | `parse_docker_image` | Parse a Docker image reference into its components |
 
-### Data (4 tools)
+### Data (5 tools)
 | Tool | Description |
 |------|-------------|
 | `validate_yaml` | Validate YAML syntax |
 | `toml_to_json` | Convert TOML to JSON |
 | `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) |
 
 ### CSS (2 tools)
 | Tool | Description |
@@ -232,6 +235,11 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 |------|-------------|
 | `read_image_info` | Read format, dimensions, bit depth, and alpha channel from image bytes: no decoding required. Supports PNG, JPEG, GIF, WebP, BMP |
 
+### PDF (1 tool)
+| Tool | Description |
+|------|-------------|
+| `read_pdf_metadata` | Read title, author, dates, page count, and encryption flag from a PDF's trailer/Info dictionary: no PDF rendering library required |
+
 ## Requirements
 
 - Node.js 18+

package/dist/index.js

@@ -1398,5 +1398,293 @@ server.tool("read_image_info", "Read image format, dimensions, and color info di
   const bytes = new Uint8Array(Buffer.from(image_base64.replace(/^data:.*;base64,/, ""), "base64"));
   return { content: [{ type: "text", text: JSON.stringify(_readImageInfo(bytes), null, 2) }] };
 });
+function _parseHar(input) {
+  if (!input || !input.trim()) return { error: "Input is empty" };
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch (e) {
+    return { error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (typeof data !== "object" || data === null || !("log" in data)) {
+    return { error: 'Not a valid HAR file: missing "log" property' };
+  }
+  const log = data.log;
+  if (typeof log !== "object" || log === null || !Array.isArray(log.entries)) {
+    return { error: 'Not a valid HAR file: "log.entries" must be an array' };
+  }
+  const logObj = log;
+  const entries = [];
+  const methods = {};
+  const statusCodes = {};
+  let totalSize = 0;
+  let totalTime = 0;
+  let failedRequests = 0;
+  for (const raw of logObj.entries) {
+    if (typeof raw !== "object" || raw === null) continue;
+    const e = raw;
+    const request = e.request ?? {};
+    const response = e.response ?? {};
+    const content = response.content ?? {};
+    const method = typeof request.method === "string" ? request.method : "GET";
+    const url = typeof request.url === "string" ? request.url : "";
+    const status = typeof response.status === "number" ? response.status : 0;
+    const statusText = typeof response.statusText === "string" ? response.statusText : "";
+    const httpVersion = typeof response.httpVersion === "string" ? response.httpVersion : "";
+    const mimeType = typeof content.mimeType === "string" ? content.mimeType : "";
+    const size = typeof content.size === "number" && content.size > 0 ? content.size : 0;
+    const time = typeof e.time === "number" ? e.time : 0;
+    const startedDateTime = typeof e.startedDateTime === "string" ? e.startedDateTime : "";
+    entries.push({ method, url, status, statusText, httpVersion, mimeType, size, time, startedDateTime });
+    methods[method] = (methods[method] ?? 0) + 1;
+    if (status > 0) statusCodes[String(status)] = (statusCodes[String(status)] ?? 0) + 1;
+    totalSize += size;
+    totalTime += time;
+    if (status === 0 || status >= 400) failedRequests++;
+  }
+  const totalRequests = entries.length;
+  const avgTime = totalRequests > 0 ? Math.round(totalTime / totalRequests * 100) / 100 : 0;
+  const creator = logObj.creator ?? {};
+  return {
+    version: typeof logObj.version === "string" ? logObj.version : "",
+    creator: { name: typeof creator.name === "string" ? creator.name : "", version: typeof creator.version === "string" ? creator.version : "" },
+    entries,
+    summary: { totalRequests, totalSize, totalTime, avgTime, failedRequests, methods, statusCodes }
+  };
+}
+function _validateNdjson(input) {
+  const rawLines = input.split("\n");
+  const lines = [];
+  let validCount = 0;
+  rawLines.forEach((raw, idx) => {
+    if (raw.trim() === "") return;
+    const lineNum = idx + 1;
+    try {
+      JSON.parse(raw);
+      lines.push({ line: lineNum, raw, valid: true });
+      validCount++;
+    } catch (e) {
+      lines.push({ line: lineNum, raw, valid: false, error: e instanceof Error ? e.message : String(e) });
+    }
+  });
+  return { valid: lines.length > 0 && validCount === lines.length, totalLines: lines.length, validLines: validCount, invalidLines: lines.length - validCount, lines };
+}
+server.tool(
+  "parse_har",
+  "Parse a browser DevTools .har network export into a readable list of requests (method, URL, status, size, timing) plus aggregate summary stats.",
+  { har: z.string().describe("Raw HAR file contents (JSON)") },
+  async ({ har }) => {
+    const result = _parseHar(har);
+    if ("error" in result) return errText(result);
+    return text(JSON.stringify(result, null, 2));
+  }
+);
+server.tool(
+  "format_ndjson",
+  "Validate newline-delimited JSON (NDJSON/JSON Lines), report per-line errors, and pretty-print each valid line.",
+  {
+    input: z.string().describe("NDJSON content: one JSON value per line"),
+    indent: z.number().int().default(2).describe("Spaces per indent level")
+  },
+  async ({ input, indent }) => {
+    const validation = _validateNdjson(input);
+    if (!validation.valid) {
+      const firstError = validation.lines.find((l) => !l.valid);
+      return errText({ error: firstError ? `Line ${firstError.line}: ${firstError.error}` : "Invalid NDJSON" });
+    }
+    const formatted = validation.lines.map((l) => JSON.stringify(JSON.parse(l.raw), null, indent)).join("\n");
+    return text(formatted);
+  }
+);
+function _decodePdfString(raw, isHex) {
+  const bytes = [];
+  if (isHex) {
+    const hex = raw.replace(/\s+/g, "");
+    const padded = hex.length % 2 === 0 ? hex : hex + "0";
+    for (let i = 0; i < padded.length; i += 2) bytes.push(parseInt(padded.slice(i, i + 2), 16));
+  } else {
+    const s = raw.replace(/\\\r\n|\\\r|\\\n/g, "");
+    for (let i = 0; i < s.length; i++) {
+      const ch = s[i];
+      if (ch === "\\" && i + 1 < s.length) {
+        const next = s[i + 1];
+        if (next === "n") {
+          bytes.push(10);
+          i++;
+        } else if (next === "r") {
+          bytes.push(13);
+          i++;
+        } else if (next === "t") {
+          bytes.push(9);
+          i++;
+        } else if (next === "b") {
+          bytes.push(8);
+          i++;
+        } else if (next === "f") {
+          bytes.push(12);
+          i++;
+        } else if (next === "(" || next === ")" || next === "\\") {
+          bytes.push(next.charCodeAt(0));
+          i++;
+        } else if (/[0-7]/.test(next)) {
+          let oct = next;
+          i++;
+          for (let k = 0; k < 2 && i + 1 < s.length && /[0-7]/.test(s[i + 1]); k++) {
+            i++;
+            oct += s[i];
+          }
+          bytes.push(parseInt(oct, 8) & 255);
+        } else {
+          bytes.push(next.charCodeAt(0));
+          i++;
+        }
+      } else {
+        bytes.push(ch.charCodeAt(0) & 255);
+      }
+    }
+  }
+  if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+    let out = "";
+    for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode(bytes[i] << 8 | bytes[i + 1]);
+    return out;
+  }
+  return bytes.map((b) => String.fromCharCode(b)).join("");
+}
+function _extractPdfField(dict, key) {
+  const litMatch = dict.match(new RegExp(`/${key}\\s*\\(((?:\\\\.|[^\\\\()])*)\\)`));
+  if (litMatch) return _decodePdfString(litMatch[1], false);
+  const hexMatch = dict.match(new RegExp(`/${key}\\s*<([0-9A-Fa-f\\s]*)>`));
+  if (hexMatch) return _decodePdfString(hexMatch[1], true);
+  return null;
+}
+function _findPdfObject(text2, objNum, gen) {
+  const m = text2.match(new RegExp(`(?:^|[^0-9])${objNum}\\s+${gen}\\s+obj([\\s\\S]*?)endobj`));
+  return m ? m[1] : null;
+}
+function _parsePdfDate(raw) {
+  const m = raw.match(/^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([Z+-])?(\d{2})?'?(\d{2})?'?/);
+  if (!m) return null;
+  const [, y, mo = "01", d = "01", h = "00", mi = "00", s = "00", tz, tzh, tzm] = m;
+  let iso = `${y}-${mo}-${d}T${h}:${mi}:${s}`;
+  if (tz === "Z") iso += "Z";
+  else if (tz === "+" || tz === "-") iso += `${tz}${tzh ?? "00"}:${tzm ?? "00"}`;
+  return iso;
+}
+function _readPdfMetadata(bytes) {
+  if (bytes.length < 8) return { error: "File too small to be a PDF" };
+  const latin1 = (b) => {
+    let out = "";
+    for (let i = 0; i < b.length; i += 32768) out += String.fromCharCode(...b.subarray(i, i + 32768));
+    return out;
+  };
+  const header = latin1(bytes.subarray(0, 16));
+  const versionMatch = header.match(/%PDF-(\d\.\d)/);
+  if (!versionMatch) return { error: "Not a valid PDF file (missing %PDF header)" };
+  const version = versionMatch[1];
+  const text2 = latin1(bytes);
+  const trailerMatches = [...text2.matchAll(/trailer\s*<<([\s\S]*?)>>/g)];
+  let infoDict = null;
+  let encrypted = false;
+  if (trailerMatches.length > 0) {
+    const trailer = trailerMatches[trailerMatches.length - 1][1];
+    encrypted = /\/Encrypt\s+\d+\s+\d+\s+R/.test(trailer);
+    const infoRef = trailer.match(/\/Info\s+(\d+)\s+(\d+)\s+R/);
+    if (infoRef) infoDict = _findPdfObject(text2, Number(infoRef[1]), Number(infoRef[2]));
+  }
+  const objBlocks = [...text2.matchAll(/(\d+)\s+(\d+)\s+obj([\s\S]*?)endobj/g)];
+  if (!infoDict) {
+    for (const b of objBlocks) {
+      if (/\/(Title|Author|Producer|Creator|CreationDate)\b/.test(b[3]) && !/\/Type\s*\/(Page|Pages|Catalog|Font)\b/.test(b[3])) {
+        infoDict = b[3];
+        break;
+      }
+    }
+  }
+  const title = infoDict ? _extractPdfField(infoDict, "Title") : null;
+  const author = infoDict ? _extractPdfField(infoDict, "Author") : null;
+  const subject = infoDict ? _extractPdfField(infoDict, "Subject") : null;
+  const keywords = infoDict ? _extractPdfField(infoDict, "Keywords") : null;
+  const creator = infoDict ? _extractPdfField(infoDict, "Creator") : null;
+  const producer = infoDict ? _extractPdfField(infoDict, "Producer") : null;
+  const creationDateRaw = infoDict ? _extractPdfField(infoDict, "CreationDate") : null;
+  const modDateRaw = infoDict ? _extractPdfField(infoDict, "ModDate") : null;
+  let pageCount = null;
+  for (const b of objBlocks) {
+    if (!/\/Type\s*\/Pages\b/.test(b[3])) continue;
+    const countMatch = b[3].match(/\/Count\s+(\d+)/);
+    if (countMatch) {
+      const c = Number(countMatch[1]);
+      if (pageCount === null || c > pageCount) pageCount = c;
+    }
+  }
+  if (pageCount === null) {
+    const pageMatches = text2.match(/\/Type\s*\/Page(?!s)\b/g);
+    if (pageMatches) pageCount = pageMatches.length;
+  }
+  return {
+    version,
+    pageCount,
+    title,
+    author,
+    subject,
+    keywords,
+    creator,
+    producer,
+    creationDate: creationDateRaw ? _parsePdfDate(creationDateRaw) ?? creationDateRaw : null,
+    modDate: modDateRaw ? _parsePdfDate(modDateRaw) ?? modDateRaw : null,
+    encrypted
+  };
+}
+server.tool("read_pdf_metadata", "Read PDF metadata (title, author, dates, page count, encryption flag) directly from the trailer/Info dictionary: no PDF rendering library required.", { pdf_base64: z.string().describe("Base64-encoded PDF bytes, optionally prefixed with a data: URL scheme") }, async ({ pdf_base64 }) => {
+  const bytes = new Uint8Array(Buffer.from(pdf_base64.replace(/^data:.*;base64,/, ""), "base64"));
+  const result = _readPdfMetadata(bytes);
+  if ("error" in result) return errText(result);
+  return text(JSON.stringify(result, null, 2));
+});
+function _parseJwks(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return { error: "No input provided" };
+  let data;
+  try {
+    data = JSON.parse(trimmed);
+  } catch (e) {
+    return { error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  let rawKeys;
+  if (data && typeof data === "object" && Array.isArray(data.keys)) {
+    rawKeys = data.keys;
+  } else if (data && typeof data === "object" && typeof data.kty === "string") {
+    rawKeys = [data];
+  } else {
+    return { error: 'Input must be a JWKS object with a "keys" array, or a single JWK object with a "kty" field' };
+  }
+  const base64urlByteLength = (s) => Math.floor(s.replace(/=+$/, "").length * 6 / 8);
+  const keys = rawKeys.map((k) => {
+    const key = k ?? {};
+    const kty = typeof key.kty === "string" ? key.kty : "unknown";
+    let keySize = null;
+    let curve;
+    if (kty === "RSA" && typeof key.n === "string") keySize = base64urlByteLength(key.n) * 8;
+    else if ((kty === "EC" || kty === "OKP") && typeof key.crv === "string") curve = key.crv;
+    else if (kty === "oct" && typeof key.k === "string") keySize = base64urlByteLength(key.k) * 8;
+    return {
+      kty,
+      use: typeof key.use === "string" ? key.use : void 0,
+      alg: typeof key.alg === "string" ? key.alg : void 0,
+      kid: typeof key.kid === "string" ? key.kid : void 0,
+      keySize,
+      curve
+    };
+  });
+  const kidCounts = /* @__PURE__ */ new Map();
+  for (const k of keys) if (k.kid) kidCounts.set(k.kid, (kidCounts.get(k.kid) ?? 0) + 1);
+  const duplicateKids = [...kidCounts.entries()].filter(([, c]) => c > 1).map(([kid]) => kid);
+  return { keys, count: keys.length, duplicateKids };
+}
+server.tool("parse_jwks", "Parse a JSON Web Key Set (or a single bare JWK) and summarize each key's type, use, algorithm, key ID, and approximate size. Does not verify or use the keys cryptographically.", { input: z.string().describe('JWKS JSON (a "keys" array) or a single JWK object') }, async ({ input }) => {
+  const result = _parseJwks(input);
+  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,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.4.1",
-  "description": "MCP server exposing 97 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.6.0",
+  "description": "MCP server exposing 101 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",
   "homepage": "https://utilix.tech/mcp",