@utilix-tech/mcp 0.6.0 → 0.7.0

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/mcp
 
-MCP server exposing 101 developer utility tools to Claude, Cursor, VS Code Copilot, and any [Model Context Protocol](https://modelcontextprotocol.io) compatible AI assistant.
+MCP server exposing 102 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.
 
@@ -230,10 +230,11 @@ claude mcp add utilix -- npx -y @utilix-tech/mcp
 | `compress_json` | Compress JSON for LLM context budgets |
 | `diff_json_detailed` | Diff two parsed JSON values, returning every path with its op and unchanged paths |
 
-### Image (1 tool)
+### Image (2 tools)
 | Tool | Description |
 |------|-------------|
 | `read_image_info` | Read format, dimensions, bit depth, and alpha channel from image bytes: no decoding required. Supports PNG, JPEG, GIF, WebP, BMP |
+| `read_exif_data` | Read camera make/model, orientation, timestamps, exposure settings, and GPS coordinates from a JPEG's EXIF data |
 
 ### PDF (1 tool)
 | Tool | Description |

package/dist/index.js

@@ -1641,6 +1641,196 @@ server.tool("read_pdf_metadata", "Read PDF metadata (title, author, dates, page
   if ("error" in result) return errText(result);
   return text(JSON.stringify(result, null, 2));
 });
+var _EXIF_ORIENTATION_LABELS = {
+  1: "Normal",
+  2: "Mirrored horizontal",
+  3: "Rotated 180\xB0",
+  4: "Mirrored vertical",
+  5: "Mirrored horizontal, rotated 90\xB0 CCW",
+  6: "Rotated 90\xB0 CW",
+  7: "Mirrored horizontal, rotated 90\xB0 CW",
+  8: "Rotated 90\xB0 CCW"
+};
+function _tu16(r, o) {
+  return r.view.getUint16(o, r.little);
+}
+function _tu32(r, o) {
+  return r.view.getUint32(o, r.little);
+}
+function _readIfdEntries(r, ifdOffset) {
+  if (ifdOffset < 0 || ifdOffset + 2 > r.bytes.length) return null;
+  const numEntries = _tu16(r, ifdOffset);
+  const entries = [];
+  for (let i = 0; i < numEntries; i++) {
+    const entryOffset = ifdOffset + 2 + i * 12;
+    if (entryOffset + 12 > r.bytes.length) break;
+    entries.push({ tag: _tu16(r, entryOffset), type: _tu16(r, entryOffset + 2), count: _tu32(r, entryOffset + 4), valueOffsetField: entryOffset + 8 });
+  }
+  return { entries };
+}
+function _findExifEntry(entries, tag) {
+  return entries.find((e) => e.tag === tag);
+}
+function _readExifAscii(r, entry) {
+  const size = entry.count;
+  const inline = size <= 4;
+  const dataOffset = inline ? entry.valueOffsetField : r.tiffStart + _tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + size > r.bytes.length) return null;
+  let out = "";
+  for (let i = 0; i < size; i++) {
+    const c = r.bytes[dataOffset + i];
+    if (c === 0) break;
+    out += String.fromCharCode(c);
+  }
+  const trimmed = out.trim();
+  return trimmed || null;
+}
+function _readExifRational(r, entry) {
+  const dataOffset = r.tiffStart + _tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 8 > r.bytes.length) return null;
+  return { num: _tu32(r, dataOffset), den: _tu32(r, dataOffset + 4) };
+}
+function _readExifGpsCoordinate(r, entries, valueTag, refTag) {
+  const valueEntry = _findExifEntry(entries, valueTag);
+  if (!valueEntry) return null;
+  const dataOffset = r.tiffStart + _tu32(r, valueEntry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 24 > r.bytes.length) return null;
+  const deg = _tu32(r, dataOffset) / (_tu32(r, dataOffset + 4) || 1);
+  const min = _tu32(r, dataOffset + 8) / (_tu32(r, dataOffset + 12) || 1);
+  const sec = _tu32(r, dataOffset + 16) / (_tu32(r, dataOffset + 20) || 1);
+  let decimal = deg + min / 60 + sec / 3600;
+  const refEntry = _findExifEntry(entries, refTag);
+  const ref = refEntry ? _readExifAscii(r, refEntry) : null;
+  if (ref === "S" || ref === "W") decimal = -decimal;
+  return Math.round(decimal * 1e6) / 1e6;
+}
+function _gcdExif(a, b) {
+  return b === 0 ? a : _gcdExif(b, a % b);
+}
+function _round2Exif(n) {
+  return Math.round(n * 100) / 100;
+}
+function _formatExposureTime(num, den) {
+  if (num === 0) return "0s";
+  if (num >= den) return `${_round2Exif(num / den)}s`;
+  const divisor = _gcdExif(num, den) || 1;
+  const n = num / divisor;
+  const d = den / divisor;
+  return `1/${Math.round(d / n)}`;
+}
+function _readExifData(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return { error: "Not a JPEG file (EXIF is only read from JPEG files)" };
+  }
+  let offset = 2;
+  let exifStart = -1;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    if (marker === 217 || marker === 218) break;
+    const segmentLength = bytes[offset + 2] << 8 | bytes[offset + 3];
+    if (marker === 225) {
+      const idOffset = offset + 4;
+      if (idOffset + 6 <= bytes.length && bytes[idOffset] === 69 && bytes[idOffset + 1] === 120 && bytes[idOffset + 2] === 105 && bytes[idOffset + 3] === 102 && bytes[idOffset + 4] === 0 && bytes[idOffset + 5] === 0) {
+        exifStart = idOffset + 6;
+        break;
+      }
+    }
+    offset += 2 + segmentLength;
+  }
+  if (exifStart === -1) return { error: "No EXIF segment found in this JPEG" };
+  if (exifStart + 8 > bytes.length) return { error: "Truncated EXIF segment" };
+  const byteOrder = String.fromCharCode(bytes[exifStart], bytes[exifStart + 1]);
+  if (byteOrder !== "II" && byteOrder !== "MM") return { error: "Invalid TIFF byte order marker in EXIF data" };
+  const little = byteOrder === "II";
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const r = { bytes, view, little, tiffStart: exifStart };
+  if (_tu16(r, exifStart + 2) !== 42) return { error: "Invalid TIFF magic number in EXIF data" };
+  const ifd0Offset = exifStart + _tu32(r, exifStart + 4);
+  const ifd0 = _readIfdEntries(r, ifd0Offset);
+  if (!ifd0) return { error: "Could not read IFD0 from EXIF data" };
+  const result = { tagCount: ifd0.entries.length };
+  const makeEntry = _findExifEntry(ifd0.entries, 271);
+  if (makeEntry) {
+    const v = _readExifAscii(r, makeEntry);
+    if (v) result.make = v;
+  }
+  const modelEntry = _findExifEntry(ifd0.entries, 272);
+  if (modelEntry) {
+    const v = _readExifAscii(r, modelEntry);
+    if (v) result.model = v;
+  }
+  const softwareEntry = _findExifEntry(ifd0.entries, 305);
+  if (softwareEntry) {
+    const v = _readExifAscii(r, softwareEntry);
+    if (v) result.software = v;
+  }
+  const dateTimeEntry = _findExifEntry(ifd0.entries, 306);
+  if (dateTimeEntry) {
+    const v = _readExifAscii(r, dateTimeEntry);
+    if (v) result.dateTime = v;
+  }
+  const orientEntry = _findExifEntry(ifd0.entries, 274);
+  if (orientEntry) {
+    const v = _tu16(r, orientEntry.valueOffsetField);
+    result.orientation = v;
+    result.orientationLabel = _EXIF_ORIENTATION_LABELS[v] ?? "Unknown";
+  }
+  const exifIfdPtr = _findExifEntry(ifd0.entries, 34665);
+  if (exifIfdPtr) {
+    const subOffset = exifStart + _tu32(r, exifIfdPtr.valueOffsetField);
+    const sub = _readIfdEntries(r, subOffset);
+    if (sub) {
+      const dtoEntry = _findExifEntry(sub.entries, 36867);
+      if (dtoEntry) {
+        const v = _readExifAscii(r, dtoEntry);
+        if (v) result.dateTimeOriginal = v;
+      }
+      const expEntry = _findExifEntry(sub.entries, 33434);
+      if (expEntry) {
+        const rat = _readExifRational(r, expEntry);
+        if (rat && rat.den !== 0) result.exposureTime = _formatExposureTime(rat.num, rat.den);
+      }
+      const fEntry = _findExifEntry(sub.entries, 33437);
+      if (fEntry) {
+        const rat = _readExifRational(r, fEntry);
+        if (rat && rat.den !== 0) result.fNumber = _round2Exif(rat.num / rat.den);
+      }
+      const isoEntry = _findExifEntry(sub.entries, 34855);
+      if (isoEntry) result.isoSpeed = _tu16(r, isoEntry.valueOffsetField);
+      const focalEntry = _findExifEntry(sub.entries, 37386);
+      if (focalEntry) {
+        const rat = _readExifRational(r, focalEntry);
+        if (rat && rat.den !== 0) result.focalLength = _round2Exif(rat.num / rat.den);
+      }
+    }
+  }
+  const gpsIfdPtr = _findExifEntry(ifd0.entries, 34853);
+  if (gpsIfdPtr) {
+    const gpsOffset = exifStart + _tu32(r, gpsIfdPtr.valueOffsetField);
+    const gps = _readIfdEntries(r, gpsOffset);
+    if (gps) {
+      const lat = _readExifGpsCoordinate(r, gps.entries, 2, 1);
+      const lon = _readExifGpsCoordinate(r, gps.entries, 4, 3);
+      if (lat !== null) result.gpsLatitude = lat;
+      if (lon !== null) result.gpsLongitude = lon;
+    }
+  }
+  return result;
+}
+server.tool("read_exif_data", "Read common EXIF tags (camera make/model, orientation, timestamps, exposure settings, GPS coordinates) directly from a JPEG's APP1 segment. Only JPEG is supported.", { image_base64: z.string().describe("Base64-encoded JPEG bytes, optionally prefixed with a data: URL scheme") }, async ({ image_base64 }) => {
+  const bytes = new Uint8Array(Buffer.from(image_base64.replace(/^data:.*;base64,/, ""), "base64"));
+  const result = _readExifData(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" };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@utilix-tech/mcp",
-  "version": "0.6.0",
-  "description": "MCP server exposing 101 Utilix developer tools to Claude, Cursor, VS Code Copilot, and any MCP-compatible AI assistant.",
+  "version": "0.7.0",
+  "description": "MCP server exposing 102 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",