stayput-mcp 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# StayPut MCP server
+
+Local PDF and photo tools for Claude, Cursor, VS Code and any other app that speaks the [Model Context Protocol](https://modelcontextprotocol.io). Ask your assistant to merge PDFs, pull out pages, or remove the GPS location from a photo, and it does the work on your own machine.
+
+It runs the same code as [stayput.dev](https://stayput.dev), the browser version. **Your files are read from disk and written back to disk; nothing is uploaded, and the server makes no network requests.** It is free and open source (MIT), with no account and no API key.
+
+## Tools
+
+| Tool | What it does |
+| --- | --- |
+| `merge_pdfs` | Combine PDFs into one, in the order given |
+| `extract_pdf_pages` | Keep only some pages, reorder them ("3,1,2") or drop pages |
+| `split_pdf` | Split into one file per page, or every N pages |
+| `rotate_pdf` | Rotate all pages or chosen pages by 90, 180 or 270 degrees |
+| `number_pdf_pages` | Stamp page numbers, e.g. "Page {n} of {total}" |
+| `pdf_info` | Page count, page sizes and title |
+| `images_to_pdf` | JPG and PNG images into one PDF, one per page, no re-compression |
+| `inspect_image_metadata` | Show GPS location, camera, capture time and other hidden metadata in a photo |
+| `strip_image_metadata` | Write a copy of a JPG, PNG or WebP with EXIF, GPS, XMP and comments removed, without re-encoding |
+
+Every tool writes a **new** file and returns its path. Input files are never modified, and an existing file is never overwritten (you get `file-1.pdf` instead). Encrypted PDFs (bank statements, forms with printing restrictions) are decrypted locally with qpdf; for PDFs that need a password to open, the assistant passes it in the `password` argument.
+
+## Install
+
+Requires Node.js 20 or newer.
+
+**Claude Code**
+
+```sh
+claude mcp add stayput -- npx -y stayput-mcp
+```
+
+**Claude Desktop, Cursor, Windsurf and other JSON configs** (`claude_desktop_config.json`, `.cursor/mcp.json`, ...)
+
+```json
+{
+  "mcpServers": {
+    "stayput": {
+      "command": "npx",
+      "args": ["-y", "stayput-mcp"]
+    }
+  }
+}
+```
+
+**VS Code**
+
+```sh
+code --add-mcp '{"name":"stayput","command":"npx","args":["-y","stayput-mcp"]}'
+```
+
+Then ask things like:
+
+- "Merge invoice-march.pdf and invoice-april.pdf in ~/Downloads"
+- "Take pages 2 to 5 out of contract.pdf"
+- "Does IMG_2041.jpg have a location in it? If so, make a copy without it"
+- "Number the pages of thesis.pdf, starting on page 3"
+
+Relative paths are resolved from the folder the server was started in, so absolute paths or `~/...` are the safest thing to give it.
+
+## Not covered here
+
+HEIC, WebP and AVIF conversion, compression, PDF to image and PDF signing need a browser engine. They are on [stayput.dev](https://stayput.dev), which works the same way: in your browser, nothing uploaded.
+
+## Development
+
+```sh
+cd mcp
+npm install
+npm test   # builds dist/index.js and runs the end-to-end tests
+```
+
+The tests use the site's fixtures; generate them first from the repository root with `python3 tests/fixtures/make-fixtures.py && node tests/fixtures/make-pdf.mjs` (needs Pillow and pillow-heif).
+
+The server imports the PDF and metadata code from `../src/lib` and bundles it with esbuild (`build.mjs`). Two browser-only modules are swapped at build time: `src/unlock.ts` loads qpdf from `node_modules` instead of a `<script>` tag, and `src/no-canvas.ts` stands in for the canvas helpers that only PDF compression uses.

package/dist/index.js

@@ -0,0 +1,1022 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { readFile, writeFile, mkdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+// src/unlock.ts
+import { createRequire } from "node:module";
+
+// ../src/lib/unlock.ts
+function looksEncrypted(bytes) {
+  const needle = "/Encrypt";
+  const window_ = 65536;
+  const td2 = new TextDecoder("latin1");
+  const tail = td2.decode(bytes.subarray(Math.max(0, bytes.length - window_)));
+  if (tail.includes(needle)) return true;
+  if (bytes.length > window_) {
+    const head = td2.decode(bytes.subarray(0, window_));
+    if (head.includes(needle)) return true;
+  }
+  return false;
+}
+var PasswordRequiredError = class extends Error {
+  constructor(wrong) {
+    super(wrong ? "That password did not open the PDF." : "This PDF needs a password to open.");
+    this.wrong = wrong;
+    this.name = "PasswordRequiredError";
+  }
+  wrong;
+};
+
+// src/unlock.ts
+var stderr = [];
+var modulePromise;
+function loadModule() {
+  modulePromise ??= (async () => {
+    const factory = createRequire(import.meta.url)("@neslinesli93/qpdf-wasm");
+    const original = console.error;
+    console.error = (...args) => void stderr.push(args.map(String).join(" "));
+    try {
+      return await factory({ noInitialRun: true });
+    } finally {
+      console.error = original;
+    }
+  })();
+  return modulePromise;
+}
+async function decrypt(bytes, password2) {
+  const qpdf = await loadModule();
+  qpdf.FS.writeFile("/in.pdf", bytes);
+  stderr = [];
+  let code;
+  try {
+    code = qpdf.callMain(["--decrypt", ...password2 ? [`--password=${password2}`] : [], "/in.pdf", "/out.pdf"]);
+  } catch (e) {
+    code = typeof e === "object" && e && "status" in e ? Number(e.status) : 1;
+  } finally {
+    try {
+      qpdf.FS.unlink("/in.pdf");
+    } catch {
+    }
+  }
+  const messages = stderr.join("\n");
+  if (code !== 0) {
+    if (/invalid password/i.test(messages)) throw new PasswordRequiredError(password2 !== "");
+    const detail = messages.trim().split("\n").pop()?.replace(/^this\.program:\s*(\/in\.pdf:\s*)?/, "");
+    throw new Error(`This PDF could not be unlocked${detail ? ` (${detail})` : ""}.`);
+  }
+  const out = new Uint8Array(qpdf.FS.readFile("/out.pdf"));
+  qpdf.FS.unlink("/out.pdf");
+  return out;
+}
+var currentPassword = "";
+var queue = Promise.resolve();
+function withPassword(password2, fn) {
+  const run = queue.then(async () => {
+    currentPassword = password2 ?? "";
+    try {
+      return await fn();
+    } finally {
+      currentPassword = "";
+    }
+  });
+  queue = run.catch(() => {
+  });
+  return run;
+}
+async function unlockPdf(bytes) {
+  if (!looksEncrypted(bytes)) return { bytes, unlocked: false };
+  try {
+    return { bytes: await decrypt(bytes, currentPassword), unlocked: true };
+  } catch (e) {
+    if (!(e instanceof PasswordRequiredError)) throw e;
+    throw new Error(e.wrong ? "That password did not open the PDF." : 'This PDF is password-protected. Pass its password in the "password" argument.');
+  }
+}
+
+// ../src/lib/pdf.ts
+var pdfLibPromise;
+function loadPdfLib() {
+  pdfLibPromise ??= import("pdf-lib");
+  return pdfLibPromise;
+}
+async function loadDocument(source) {
+  assertPdfHeader(source);
+  const { bytes } = await unlockPdf(source);
+  const { PDFDocument } = await loadPdfLib();
+  let doc;
+  try {
+    doc = await PDFDocument.load(bytes, { ignoreEncryption: true, updateMetadata: false });
+  } catch (e) {
+    throw new Error(`This file could not be read as a PDF. It may be damaged${e instanceof Error && e.message ? ` (${e.message.split("\n")[0]})` : ""}.`);
+  }
+  if (doc.isEncrypted) throw new Error("This PDF uses an encryption method that could not be removed in the browser.");
+  return doc;
+}
+function assertPdfHeader(bytes) {
+  if (bytes.length === 0) throw new Error("This file is empty.");
+  if (!isPdfHeader(bytes)) throw new Error("This file is not a PDF. It does not start with a PDF header.");
+}
+function isPdfHeader(bytes) {
+  const head = bytes.subarray(0, 1024);
+  for (let i = 0; i + 5 <= head.length; i++) {
+    if (head[i] === 37 && head[i + 1] === 80 && head[i + 2] === 68 && head[i + 3] === 70 && head[i + 4] === 45) return true;
+  }
+  return false;
+}
+function visibleBox(page) {
+  const m = page.getMediaBox();
+  const c = page.getCropBox();
+  const x0 = Math.max(m.x, c.x);
+  const y0 = Math.max(m.y, c.y);
+  const x1 = Math.min(m.x + m.width, c.x + c.width);
+  const y1 = Math.min(m.y + m.height, c.y + c.height);
+  if (x1 - x0 <= 0 || y1 - y0 <= 0) return { x: m.x, y: m.y, width: m.width, height: m.height };
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+async function mergePdfs(sources, onProgress) {
+  const { PDFDocument } = await loadPdfLib();
+  const out = await PDFDocument.create();
+  for (let i = 0; i < sources.length; i++) {
+    const src = await loadDocument(sources[i]);
+    const pages = await out.copyPages(src, src.getPageIndices());
+    for (const p of pages) out.addPage(p);
+    onProgress?.(i + 1);
+  }
+  return out.save({ useObjectStreams: true });
+}
+async function extractPages(source, indexes) {
+  const { PDFDocument } = await loadPdfLib();
+  const src = await loadDocument(source);
+  const out = await PDFDocument.create();
+  const pages = await out.copyPages(src, indexes);
+  for (const p of pages) out.addPage(p);
+  return out.save({ useObjectStreams: true });
+}
+async function rotatePages(source, rotations) {
+  const { degrees } = await loadPdfLib();
+  const doc = await loadDocument(source);
+  doc.getPages().forEach((page, i) => {
+    const r = rotations[i];
+    if (r !== void 0) page.setRotation(degrees((r % 360 + 360) % 360));
+  });
+  return doc.save({ useObjectStreams: true });
+}
+var PAGE_SIZES = {
+  a4: [595.28, 841.89],
+  letter: [612, 792]
+};
+async function imagesToPdf(images, opts, onProgress) {
+  const { PDFDocument } = await loadPdfLib();
+  const doc = await PDFDocument.create();
+  for (let i = 0; i < images.length; i++) {
+    const img = images[i];
+    const embedded = img.kind === "jpg" ? await doc.embedJpg(img.bytes) : await doc.embedPng(img.bytes);
+    const { width: iw, height: ih } = embedded;
+    if (opts.pageSize === "fit") {
+      const page = doc.addPage([iw + opts.margin * 2, ih + opts.margin * 2]);
+      page.drawImage(embedded, { x: opts.margin, y: opts.margin, width: iw, height: ih });
+    } else {
+      let [pw, ph] = PAGE_SIZES[opts.pageSize];
+      const landscape = opts.orientation === "landscape" || opts.orientation === "auto" && iw > ih;
+      if (landscape) [pw, ph] = [ph, pw];
+      const page = doc.addPage([pw, ph]);
+      const availW = pw - opts.margin * 2;
+      const availH = ph - opts.margin * 2;
+      const scale = Math.min(availW / iw, availH / ih);
+      const w = iw * scale;
+      const h = ih * scale;
+      page.drawImage(embedded, { x: (pw - w) / 2, y: (ph - h) / 2, width: w, height: h });
+    }
+    onProgress?.(i + 1);
+  }
+  return doc.save({ useObjectStreams: true });
+}
+function hexToRgb(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return [0.2, 0.2, 0.2];
+  const n = parseInt(m[1], 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function displayedToUserSpace(page, fx, fy) {
+  const box = visibleBox(page);
+  const { width, height } = box;
+  const rot = (page.getRotation().angle % 360 + 360) % 360;
+  const [dw, dh] = rot === 90 || rot === 270 ? [height, width] : [width, height];
+  const dx = fx * dw;
+  const dy = fy * dh;
+  switch (rot) {
+    case 90:
+      return { x: box.x + width - dy, y: box.y + dx, rotate: 90, w: dw, h: dh };
+    case 180:
+      return { x: box.x + width - dx, y: box.y + height - dy, rotate: 180, w: dw, h: dh };
+    case 270:
+      return { x: box.x + dy, y: box.y + height - dx, rotate: -90, w: dw, h: dh };
+    default:
+      return { x: box.x + dx, y: box.y + dy, rotate: 0, w: dw, h: dh };
+  }
+}
+function displayedSize(page) {
+  const { width, height } = visibleBox(page);
+  const rot = (page.getRotation().angle % 360 + 360) % 360;
+  return rot === 90 || rot === 270 ? { w: height, h: width } : { w: width, h: height };
+}
+async function addPageNumbers(source, opts, onProgress) {
+  const lib = await loadPdfLib();
+  const { StandardFonts, rgb, degrees } = lib;
+  const doc = await loadDocument(source);
+  const fontName = opts.font === "times" ? StandardFonts.TimesRoman : opts.font === "courier" ? StandardFonts.Courier : StandardFonts.Helvetica;
+  const font = await doc.embedFont(fontName);
+  const pages = doc.getPages();
+  const numberedPages = pages.slice(Math.max(0, opts.firstPage));
+  const total = numberedPages.length;
+  const [r, g, b] = hexToRgb(opts.color);
+  const color = rgb(r, g, b);
+  const size2 = Math.max(4, opts.fontSize);
+  numberedPages.forEach((page, i) => {
+    const n = opts.start + i;
+    const text = opts.template.replace(/\{n\}/g, String(n)).replace(/\{total\}/g, String(opts.start + total - 1)).replace(/\{count\}/g, String(total));
+    const textWidth = font.widthOfTextAtSize(text, size2);
+    const { w: dw, h: dh } = displayedSize(page);
+    const vertical = opts.position.startsWith("top") ? dh - opts.margin - size2 * 0.75 : opts.margin;
+    const horizontal = opts.position.endsWith("left") ? opts.margin : opts.position.endsWith("right") ? dw - opts.margin - textWidth : (dw - textWidth) / 2;
+    const p = displayedToUserSpace(page, horizontal / dw, vertical / dh);
+    page.drawText(text, { x: p.x, y: p.y, size: size2, font, color, rotate: degrees(p.rotate) });
+    onProgress?.(i + 1, total);
+  });
+  return { bytes: await doc.save({ useObjectStreams: true }), numbered: total };
+}
+
+// ../src/lib/ranges.ts
+function parsePageRange(input, pageCount) {
+  const out = [];
+  const text = input.trim();
+  if (!text) throw new Error("Enter at least one page or range, for example 1-3, 5.");
+  for (const rawPart of text.split(/[,;\s]+/)) {
+    const part = rawPart.trim();
+    if (!part) continue;
+    const m = /^(\d+)(?:\s*-\s*(\d+))?$/.exec(part);
+    if (!m) throw new Error(`"${part}" is not a page number or range.`);
+    const a = Number(m[1]);
+    const b = m[2] !== void 0 ? Number(m[2]) : a;
+    if (a < 1 || b < 1 || a > pageCount || b > pageCount) {
+      throw new Error(`Page ${a > pageCount ? a : b} is out of range. This document has ${pageCount} page${pageCount === 1 ? "" : "s"}.`);
+    }
+    const step = a <= b ? 1 : -1;
+    for (let p = a; step > 0 ? p <= b : p >= b; p += step) out.push(p - 1);
+  }
+  if (out.length === 0) throw new Error("Enter at least one page.");
+  return out;
+}
+function chunkPages(pageCount, n) {
+  if (n < 1) throw new Error("Pages per file must be at least 1.");
+  const chunks = [];
+  for (let start = 0; start < pageCount; start += n) {
+    const chunk = [];
+    for (let p = start; p < Math.min(start + n, pageCount); p++) chunk.push(p);
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+function describePages(indexes) {
+  if (indexes.length === 0) return "";
+  const parts = [];
+  let start = indexes[0];
+  let prev = start;
+  for (let i = 1; i <= indexes.length; i++) {
+    const cur = indexes[i];
+    if (cur !== void 0 && cur === prev + 1) {
+      prev = cur;
+      continue;
+    }
+    parts.push(start === prev ? `${start + 1}` : `${start + 1}-${prev + 1}`);
+    if (cur !== void 0) {
+      start = cur;
+      prev = cur;
+    }
+  }
+  return parts.join(",");
+}
+
+// ../src/lib/exif.ts
+var td = new TextDecoder("latin1");
+function ascii(b, start, len) {
+  return td.decode(b.subarray(start, start + len));
+}
+function parseTiff(tiff) {
+  const info = { hasGps: false };
+  if (tiff.length < 8) return info;
+  const le = tiff[0] === 73 && tiff[1] === 73;
+  const be = tiff[0] === 77 && tiff[1] === 77;
+  if (!le && !be) return info;
+  const dv = new DataView(tiff.buffer, tiff.byteOffset, tiff.byteLength);
+  const u16 = (o) => dv.getUint16(o, le);
+  const u32 = (o) => dv.getUint32(o, le);
+  if (u16(2) !== 42) return info;
+  const readAscii = (off, count) => {
+    if (count === 0) return void 0;
+    const start = count <= 4 ? off + 8 : u32(off + 8);
+    if (start + count > tiff.length) return void 0;
+    return ascii(tiff, start, count).replace(/\0+$/, "").trim() || void 0;
+  };
+  const visited = /* @__PURE__ */ new Set();
+  const readIfd = (offset, isExifSub) => {
+    if (offset < 8 || offset + 2 > tiff.length || visited.has(offset)) return;
+    visited.add(offset);
+    const n = u16(offset);
+    for (let i = 0; i < n; i++) {
+      const e = offset + 2 + i * 12;
+      if (e + 12 > tiff.length) return;
+      const tag = u16(e);
+      const type = u16(e + 2);
+      const count = u32(e + 4);
+      switch (tag) {
+        case 274:
+          if (!isExifSub && type === 3) {
+            info.orientation = u16(e + 8);
+            info.orientationValueOffset = e + 8;
+          }
+          break;
+        case 271:
+          info.make ??= readAscii(e, count);
+          break;
+        case 272:
+          info.model ??= readAscii(e, count);
+          break;
+        case 305:
+          info.software ??= readAscii(e, count);
+          break;
+        case 306:
+          if (!info.dateTime) info.dateTime = readAscii(e, count);
+          break;
+        case 36867:
+          info.dateTime = readAscii(e, count) ?? info.dateTime;
+          break;
+        case 34665:
+          if (type === 4) readIfd(u32(e + 8), true);
+          break;
+        case 34853: {
+          if (type !== 4) break;
+          const g = u32(e + 8);
+          if (g + 2 <= tiff.length) {
+            const gn = u16(g);
+            for (let j = 0; j < gn; j++) {
+              const ge = g + 2 + j * 12;
+              if (ge + 12 > tiff.length) break;
+              const gt = u16(ge);
+              if (gt === 2 || gt === 4) {
+                info.hasGps = true;
+                break;
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+  };
+  readIfd(u32(4), false);
+  return info;
+}
+function jpegSegments(b) {
+  if (b.length < 4 || b[0] !== 255 || b[1] !== 216) throw new Error("Not a JPEG file.");
+  const segments = [];
+  let p = 2;
+  while (p + 4 <= b.length) {
+    if (b[p] !== 255) throw new Error("Corrupt JPEG structure.");
+    const marker = b[p + 1];
+    if (marker === 255) {
+      p++;
+      continue;
+    }
+    if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1) {
+      p += 2;
+      continue;
+    }
+    if (marker === 218) {
+      return { segments, scanStart: p };
+    }
+    const len = b[p + 2] << 8 | b[p + 3];
+    const seg = { marker, start: p, end: p + 2 + len, payloadStart: p + 4, payloadLength: len - 2 };
+    if (seg.end > b.length) throw new Error("Truncated JPEG file.");
+    segments.push(seg);
+    p = seg.end;
+  }
+  throw new Error("No image data found in this JPEG.");
+}
+function segKind(b, s) {
+  const head = ascii(b, s.payloadStart, Math.min(29, s.payloadLength));
+  switch (s.marker) {
+    case 225:
+      if (head.startsWith("Exif\0")) return "EXIF";
+      if (head.startsWith("http://ns.adobe.com/xap/1.0/") || head.startsWith("http://ns.adobe.com/xmp/extension/")) return "XMP";
+      return "APP1";
+    case 226:
+      if (head.startsWith("ICC_PROFILE\0")) return "ICC";
+      if (head.startsWith("MPF\0")) return "MPF";
+      return "APP2";
+    case 237:
+      return "IPTC";
+    case 254:
+      return "Comment";
+    case 224:
+      return "JFIF";
+    case 238:
+      return "Adobe";
+    default:
+      if (s.marker >= 227 && s.marker <= 239) return `APP${s.marker - 224}`;
+      return void 0;
+  }
+}
+function inspectJpeg(b) {
+  const { segments } = jpegSegments(b);
+  const kinds = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  let hasIcc = false;
+  let tiff = { hasGps: false };
+  for (const s of segments) {
+    const kind = segKind(b, s);
+    if (!kind || kind === "JFIF" || kind === "Adobe") continue;
+    if (kind === "ICC") {
+      hasIcc = true;
+      continue;
+    }
+    kinds.add(kind);
+    bytes += s.end - s.start;
+    if (kind === "EXIF") tiff = parseTiff(b.subarray(s.payloadStart + 6, s.payloadStart + s.payloadLength));
+  }
+  return { kinds: [...kinds], bytes, hasIcc, ...tiffSummary(tiff) };
+}
+function tiffSummary(t) {
+  return { hasGps: t.hasGps, orientation: t.orientation, make: t.make, model: t.model, dateTime: t.dateTime, software: t.software };
+}
+function stripJpeg(b, opts = {}) {
+  const keepIcc = opts.keepIcc ?? true;
+  const summary = inspectJpeg(b);
+  const { segments, scanStart } = jpegSegments(b);
+  const parts = [b.subarray(0, 2)];
+  let removed = 0;
+  for (const s of segments) {
+    const kind = segKind(b, s);
+    const isMeta = kind !== void 0 && kind !== "JFIF" && kind !== "Adobe";
+    const drop = isMeta && (kind !== "ICC" || !keepIcc);
+    if (drop) {
+      removed += s.end - s.start;
+      continue;
+    }
+    parts.push(b.subarray(s.start, s.end));
+  }
+  parts.push(b.subarray(scanStart));
+  if (!keepIcc && summary.hasIcc) summary.kinds.push("ICC");
+  summary.bytes = removed;
+  return { bytes: concat(parts), summary };
+}
+var PNG_SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+var PNG_META = /* @__PURE__ */ new Set(["eXIf", "tEXt", "zTXt", "iTXt", "tIME"]);
+function pngChunks(b) {
+  for (let i = 0; i < 8; i++) if (b[i] !== PNG_SIG[i]) throw new Error("Not a PNG file.");
+  const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  const chunks = [];
+  let p = 8;
+  while (p + 8 <= b.length) {
+    const length = dv.getUint32(p);
+    const type = ascii(b, p + 4, 4);
+    const end = p + 12 + length;
+    if (end > b.length) throw new Error("Truncated PNG file.");
+    chunks.push({ type, start: p, end, dataStart: p + 8, length });
+    p = end;
+    if (type === "IEND") break;
+  }
+  return chunks;
+}
+function pngKind(type) {
+  return type === "eXIf" ? "EXIF" : type === "tIME" ? "Time" : "Text";
+}
+function inspectPng(b) {
+  const chunks = pngChunks(b);
+  const kinds = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  let tiff = { hasGps: false };
+  let hasIcc = false;
+  for (const c of chunks) {
+    if (c.type === "iCCP") hasIcc = true;
+    if (!PNG_META.has(c.type)) continue;
+    const kind = pngKind(c.type);
+    if (c.type === "iTXt" && ascii(b, c.dataStart, Math.min(17, c.length)).startsWith("XML:com.adobe.xmp")) kinds.add("XMP");
+    else kinds.add(kind);
+    bytes += c.end - c.start;
+    if (c.type === "eXIf") tiff = parseTiff(b.subarray(c.dataStart, c.dataStart + c.length));
+  }
+  return { kinds: [...kinds], bytes, hasIcc, ...tiffSummary(tiff) };
+}
+function stripPng(b, opts = {}) {
+  const keepIcc = opts.keepIcc ?? true;
+  const summary = inspectPng(b);
+  const chunks = pngChunks(b);
+  const parts = [b.subarray(0, 8)];
+  let removed = 0;
+  for (const c of chunks) {
+    const drop = PNG_META.has(c.type) || c.type === "iCCP" && !keepIcc;
+    if (drop) {
+      removed += c.end - c.start;
+      continue;
+    }
+    parts.push(b.subarray(c.start, c.end));
+  }
+  if (!keepIcc && summary.hasIcc) summary.kinds.push("ICC");
+  summary.bytes = removed;
+  return { bytes: concat(parts), summary };
+}
+function webpChunks(b) {
+  if (b.length < 12 || ascii(b, 0, 4) !== "RIFF" || ascii(b, 8, 4) !== "WEBP") throw new Error("Not a WebP file.");
+  const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  const chunks = [];
+  let p = 12;
+  while (p + 8 <= b.length) {
+    const fourcc = ascii(b, p, 4);
+    const length = dv.getUint32(p + 4, true);
+    const end = p + 8 + length + (length & 1);
+    if (p + 8 + length > b.length) throw new Error("Truncated WebP file.");
+    chunks.push({ fourcc, start: p, end: Math.min(end, b.length), dataStart: p + 8, length });
+    p = end;
+  }
+  return chunks;
+}
+function inspectWebp(b) {
+  const chunks = webpChunks(b);
+  const kinds = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  let hasIcc = false;
+  let tiff = { hasGps: false };
+  for (const c of chunks) {
+    if (c.fourcc === "ICCP") hasIcc = true;
+    if (c.fourcc === "EXIF") {
+      kinds.add("EXIF");
+      bytes += c.end - c.start;
+      let t = b.subarray(c.dataStart, c.dataStart + c.length);
+      if (ascii(t, 0, 4) === "Exif") t = t.subarray(6);
+      tiff = parseTiff(t);
+    } else if (c.fourcc === "XMP ") {
+      kinds.add("XMP");
+      bytes += c.end - c.start;
+    }
+  }
+  return { kinds: [...kinds], bytes, hasIcc, ...tiffSummary(tiff) };
+}
+function stripWebp(b, opts = {}) {
+  const keepIcc = opts.keepIcc ?? true;
+  const summary = inspectWebp(b);
+  const chunks = webpChunks(b);
+  const body = [];
+  let removed = 0;
+  for (const c of chunks) {
+    const drop = c.fourcc === "EXIF" || c.fourcc === "XMP " || c.fourcc === "ICCP" && !keepIcc;
+    if (drop) {
+      removed += c.end - c.start;
+      continue;
+    }
+    if (c.fourcc === "VP8X") {
+      const chunk = b.slice(c.start, c.end);
+      let flags = chunk[8];
+      flags &= ~8 & ~4;
+      if (!keepIcc) flags &= ~32;
+      chunk[8] = flags;
+      body.push(chunk);
+      continue;
+    }
+    body.push(b.subarray(c.start, c.end));
+  }
+  const payload = concat(body);
+  const header = new Uint8Array(12);
+  header.set([82, 73, 70, 70], 0);
+  new DataView(header.buffer).setUint32(4, payload.length + 4, true);
+  header.set([87, 69, 66, 80], 8);
+  if (!keepIcc && summary.hasIcc) summary.kinds.push("ICC");
+  summary.bytes = removed;
+  return { bytes: concat([header, payload]), summary };
+}
+function heifExifTiff(b) {
+  const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  const u32 = (o) => dv.getUint32(o);
+  const u16 = (o) => dv.getUint16(o);
+  const readN = (o, size2) => {
+    if (size2 === 0) return 0;
+    if (size2 === 4) return u32(o);
+    if (size2 === 8) return Number(dv.getBigUint64(o));
+    return u16(o);
+  };
+  const boxesIn = (start, end) => {
+    const out = [];
+    let p2 = start;
+    while (p2 + 8 <= end) {
+      let size2 = u32(p2);
+      const type = ascii(b, p2 + 4, 4);
+      let body = p2 + 8;
+      if (size2 === 1) {
+        size2 = Number(dv.getBigUint64(p2 + 8));
+        body = p2 + 16;
+      } else if (size2 === 0) size2 = end - p2;
+      if (size2 < 8 || p2 + size2 > end) break;
+      out.push({ type, start: p2, end: p2 + size2, body });
+      p2 += size2;
+    }
+    return out;
+  };
+  const meta = boxesIn(0, b.length).find((x) => x.type === "meta");
+  if (!meta) return void 0;
+  const children = boxesIn(meta.body + 4, meta.end);
+  const iinf = children.find((x) => x.type === "iinf");
+  const iloc = children.find((x) => x.type === "iloc");
+  const idat = children.find((x) => x.type === "idat");
+  if (!iinf || !iloc) return void 0;
+  const iinfVersion = b[iinf.body];
+  const countSize = iinfVersion === 0 ? 2 : 4;
+  const entriesStart = iinf.body + 4 + countSize;
+  let exifId;
+  for (const infe of boxesIn(entriesStart, iinf.end)) {
+    if (infe.type !== "infe") continue;
+    const v = b[infe.body];
+    if (v < 2) continue;
+    const id = v === 2 ? u16(infe.body + 4) : u32(infe.body + 4);
+    const itemType = ascii(b, infe.body + (v === 2 ? 8 : 10), 4);
+    if (itemType === "Exif") {
+      exifId = id;
+      break;
+    }
+  }
+  if (exifId === void 0) return void 0;
+  const version = b[iloc.body];
+  let p = iloc.body + 4;
+  const offsetSize = b[p] >> 4;
+  const lengthSize = b[p] & 15;
+  const baseOffsetSize = b[p + 1] >> 4;
+  const indexSize = version === 1 || version === 2 ? b[p + 1] & 15 : 0;
+  p += 2;
+  const itemCount = version < 2 ? u16(p) : u32(p);
+  p += version < 2 ? 2 : 4;
+  for (let i = 0; i < itemCount; i++) {
+    const itemId = version < 2 ? u16(p) : u32(p);
+    p += version < 2 ? 2 : 4;
+    let construction = 0;
+    if (version === 1 || version === 2) {
+      construction = u16(p) & 15;
+      p += 2;
+    }
+    p += 2;
+    const baseOffset = readN(p, baseOffsetSize);
+    p += baseOffsetSize;
+    const extentCount = u16(p);
+    p += 2;
+    const extents = [];
+    for (let e = 0; e < extentCount; e++) {
+      if (indexSize > 0) p += indexSize;
+      const off = readN(p, offsetSize);
+      p += offsetSize;
+      const len = readN(p, lengthSize);
+      p += lengthSize;
+      if (itemId === exifId) {
+        const abs2 = construction === 1 ? idat ? idat.body + baseOffset + off : -1 : baseOffset + off;
+        if (abs2 < 0 || abs2 + len > b.length) return void 0;
+        extents.push(b.subarray(abs2, abs2 + len));
+      }
+    }
+    if (itemId === exifId) {
+      const data = concat(extents);
+      if (data.length < 4) return void 0;
+      const tiffOffset = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(0);
+      const tiff = data.subarray(4 + tiffOffset);
+      return tiff.length >= 8 ? tiff : void 0;
+    }
+  }
+  return void 0;
+}
+function sniffFormat(b) {
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255) return "jpeg";
+  if (b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return "png";
+  if (b.length >= 12 && ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 4) === "WEBP") return "webp";
+  if (b.length >= 12 && ascii(b, 4, 4) === "ftyp") return "heif";
+  return "unknown";
+}
+function inspect(b) {
+  switch (sniffFormat(b)) {
+    case "jpeg":
+      return inspectJpeg(b);
+    case "png":
+      return inspectPng(b);
+    case "webp":
+      return inspectWebp(b);
+    case "heif": {
+      const t = heifExifTiff(b);
+      const info = t ? parseTiff(t) : { hasGps: false };
+      return { kinds: t ? ["EXIF"] : [], bytes: t?.length ?? 0, hasIcc: false, ...tiffSummary(info) };
+    }
+    default:
+      throw new Error("Only JPEG, PNG and WebP files can be cleaned losslessly.");
+  }
+}
+function strip(b, opts = {}) {
+  switch (sniffFormat(b)) {
+    case "jpeg":
+      return stripJpeg(b, opts);
+    case "png":
+      return stripPng(b, opts);
+    case "webp":
+      return stripWebp(b, opts);
+    default:
+      throw new Error("Only JPEG, PNG and WebP files can be cleaned losslessly. Convert HEIC photos first.");
+  }
+}
+function concat(parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+
+// src/server.ts
+var VERSION = "0.1.0";
+var SITE = "https://stayput.dev";
+function abs(p) {
+  const t = p.trim();
+  if (t === "~" || t.startsWith("~/")) return join(homedir(), t.slice(1));
+  return resolve(process.cwd(), t);
+}
+async function read(p) {
+  const path = abs(p);
+  try {
+    return new Uint8Array(await readFile(path));
+  } catch (e) {
+    const code = e.code;
+    throw new Error(code === "ENOENT" ? `No file at ${path}.` : code === "EISDIR" ? `${path} is a folder, not a file.` : `Could not read ${path} (${code ?? String(e)}).`);
+  }
+}
+var exists = (p) => stat(p).then(() => true, () => false);
+async function freePath(path) {
+  const ext = extname(path);
+  const stem = path.slice(0, path.length - ext.length);
+  let candidate = path;
+  for (let i = 1; await exists(candidate); i++) candidate = `${stem}-${i}${ext}`;
+  return candidate;
+}
+async function outPath(given, input, suffix, ext) {
+  if (given) return freePath(abs(given));
+  const src = abs(input);
+  return freePath(join(dirname(src), `${basename(src, extname(src))}-${suffix}${ext}`));
+}
+async function save(path, bytes) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, bytes, { flag: "wx" });
+}
+var size = (n) => n < 1024 * 1024 ? `${Math.max(1, Math.round(n / 1024))} KB` : `${(n / 1024 / 1024).toFixed(1)} MB`;
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+function ok(text, structured) {
+  return { content: [{ type: "text", text }], structuredContent: structured };
+}
+async function guard(password2, fn) {
+  try {
+    return await withPassword(password2, fn);
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }] };
+  }
+}
+async function pdfPages(bytes) {
+  return (await loadDocument(bytes)).getPageCount();
+}
+var password = z.string().optional().describe("Password for a PDF that asks for one when opened. Used only on this machine.");
+var output = z.string().optional().describe("Where to write the result. Defaults to a new file beside the input. Existing files are never overwritten; a free name like file-1.pdf is used instead.");
+function createServer() {
+  const server = new McpServer(
+    { name: "stayput", title: "StayPut", version: VERSION, websiteUrl: SITE },
+    {
+      instructions: 'Local PDF and photo tools. Paths are on this machine: absolute, ~/..., or relative to the working directory. Tools never modify or overwrite input files; they write a new file and return its path. Nothing is uploaded. Encrypted PDFs are decrypted locally; pass "password" when one is needed. For formats these tools do not cover (HEIC, WebP, AVIF conversion, compression, PDF to image), point the user to https://stayput.dev, which runs the same way in the browser.'
+    }
+  );
+  server.registerTool(
+    "pdf_info",
+    {
+      title: "PDF info",
+      description: "Read a PDF on this machine and report its page count, page sizes, title and whether it was encrypted. Use before splitting, extracting or rotating to learn how many pages there are.",
+      inputSchema: { path: z.string().describe("Path to the PDF."), password },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    ({ path, password: pw }) => guard(pw, async () => {
+      const bytes = await read(path);
+      const doc = await loadDocument(bytes);
+      const sizes = doc.getPages().map((p) => {
+        const { width, height } = p.getSize();
+        return `${Math.round(width)}x${Math.round(height)} pt`;
+      });
+      const distinct = [...new Set(sizes)];
+      const title = doc.getTitle();
+      const lines = [`${abs(path)}: ${plural(doc.getPageCount(), "page")}, ${size(bytes.length)}.`, `Page size: ${distinct.slice(0, 5).join(", ")}${distinct.length > 5 ? ", ..." : ""}.`];
+      if (title) lines.push(`Title: ${title}`);
+      return ok(lines.join("\n"), { path: abs(path), pages: doc.getPageCount(), bytes: bytes.length, pageSizes: distinct, title: title ?? null });
+    })
+  );
+  server.registerTool(
+    "merge_pdfs",
+    {
+      title: "Merge PDFs",
+      description: "Combine several PDFs on this machine into one, in the order given. The same file may appear more than once. Writes a new PDF and returns its path.",
+      inputSchema: { inputs: z.array(z.string()).min(1).describe("PDF paths, in the order their pages should appear."), output, password },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ inputs, output: out, password: pw }) => guard(pw, async () => {
+      const sources = await Promise.all(inputs.map(read));
+      const bytes = await mergePdfs(sources);
+      const dest = await outPath(out, inputs[0], "merged", ".pdf");
+      await save(dest, bytes);
+      const n = await pdfPages(bytes);
+      return ok(`Merged ${plural(inputs.length, "file")} into ${dest} (${plural(n, "page")}, ${size(bytes.length)}).`, { output: dest, pages: n, bytes: bytes.length });
+    })
+  );
+  server.registerTool(
+    "extract_pdf_pages",
+    {
+      title: "Extract, reorder or delete PDF pages",
+      description: 'Write a new PDF containing only the listed pages, in the listed order. Use it to pull out a range, reorder pages ("3,1,2") or drop pages (list the ones to keep). Pages are 1-based; ranges like "1-3, 7" and reversed ranges like "5-1" work.',
+      inputSchema: { input: z.string().describe("Path to the PDF."), pages: z.string().describe('Pages to keep, for example "1-3, 7" or "3,1,2".'), output, password },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ input, pages, output: out, password: pw }) => guard(pw, async () => {
+      const src = await read(input);
+      const indexes = parsePageRange(pages, await pdfPages(src));
+      const bytes = await extractPages(src, indexes);
+      const dest = await outPath(out, input, "pages", ".pdf");
+      await save(dest, bytes);
+      return ok(`Wrote ${dest} with ${describePages(indexes)} (${plural(indexes.length, "page")}, ${size(bytes.length)}).`, { output: dest, pages: indexes.length, bytes: bytes.length });
+    })
+  );
+  server.registerTool(
+    "split_pdf",
+    {
+      title: "Split PDF",
+      description: "Split a PDF into several files of N pages each (1 = one file per page), written into a folder. Returns the list of files.",
+      inputSchema: {
+        input: z.string().describe("Path to the PDF."),
+        pages_per_file: z.number().int().min(1).default(1).describe("Pages in each output file. Default 1."),
+        output_dir: z.string().optional().describe("Folder for the parts. Defaults to a new folder beside the input named <file>-split."),
+        password
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ input, pages_per_file, output_dir, password: pw }) => guard(pw, async () => {
+      const src = await read(input);
+      const stem = basename(abs(input), extname(input));
+      const folder = output_dir ? abs(output_dir) : await freePath(join(dirname(abs(input)), `${stem}-split`));
+      const written = [];
+      for (const chunk of chunkPages(await pdfPages(src), pages_per_file)) {
+        const first = chunk[0] + 1;
+        const last = chunk[chunk.length - 1] + 1;
+        const dest = await freePath(join(folder, `${stem}-pages-${first === last ? first : `${first}-${last}`}.pdf`));
+        await save(dest, await extractPages(src, chunk));
+        written.push(dest);
+      }
+      return ok(`Split into ${plural(written.length, "file")} in ${folder}:
+${written.map((w) => `- ${basename(w)}`).join("\n")}`, { outputDir: folder, files: written });
+    })
+  );
+  server.registerTool(
+    "rotate_pdf",
+    {
+      title: "Rotate PDF pages",
+      description: "Rotate all pages, or only the listed ones, clockwise by 90, 180 or 270 degrees, and save the rotation permanently in a new PDF.",
+      inputSchema: {
+        input: z.string().describe("Path to the PDF."),
+        degrees: z.union([z.literal(90), z.literal(180), z.literal(270)]).describe("Clockwise rotation to add."),
+        pages: z.string().optional().describe('Pages to rotate, for example "1, 3-4". Default: every page.'),
+        output,
+        password
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ input, degrees, pages, output: out, password: pw }) => guard(pw, async () => {
+      const src = await read(input);
+      const doc = await loadDocument(src);
+      const count = doc.getPageCount();
+      const chosen = new Set(pages ? parsePageRange(pages, count) : doc.getPageIndices());
+      const rotations = doc.getPages().map((p, i) => p.getRotation().angle + (chosen.has(i) ? degrees : 0));
+      const bytes = await rotatePages(src, rotations);
+      const dest = await outPath(out, input, "rotated", ".pdf");
+      await save(dest, bytes);
+      return ok(`Rotated ${plural(chosen.size, "page")} by ${degrees} degrees. Wrote ${dest} (${size(bytes.length)}).`, { output: dest, rotatedPages: chosen.size, bytes: bytes.length });
+    })
+  );
+  server.registerTool(
+    "number_pdf_pages",
+    {
+      title: "Add page numbers",
+      description: 'Stamp page numbers on a PDF. The template may use {n} for the page number and {total} for the last number, e.g. "Page {n} of {total}".',
+      inputSchema: {
+        input: z.string().describe("Path to the PDF."),
+        template: z.string().default("{n}").describe('Text to print. Default "{n}".'),
+        position: z.enum(["bottom-center", "bottom-left", "bottom-right", "top-center", "top-left", "top-right"]).default("bottom-center"),
+        start: z.number().int().default(1).describe("Number printed on the first numbered page."),
+        first_page: z.number().int().min(1).default(1).describe("First page (1-based) that gets a number; earlier pages, such as a cover, are left blank."),
+        font_size: z.number().min(4).max(72).default(11),
+        output,
+        password
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ input, template, position, start, first_page, font_size, output: out, password: pw }) => guard(pw, async () => {
+      const src = await read(input);
+      const { bytes, numbered } = await addPageNumbers(src, { template, position, start, firstPage: first_page - 1, fontSize: font_size, margin: 28, font: "helvetica", color: "#333333" });
+      const dest = await outPath(out, input, "numbered", ".pdf");
+      await save(dest, bytes);
+      return ok(`Numbered ${plural(numbered, "page")}. Wrote ${dest} (${size(bytes.length)}).`, { output: dest, numberedPages: numbered, bytes: bytes.length });
+    })
+  );
+  server.registerTool(
+    "images_to_pdf",
+    {
+      title: "Images to PDF",
+      description: "Put JPG and PNG images into one PDF, one image per page, in the order given. Images are embedded as they are, without re-compression.",
+      inputSchema: {
+        inputs: z.array(z.string()).min(1).describe("JPG or PNG paths, in page order."),
+        page_size: z.enum(["fit", "a4", "letter"]).default("fit").describe('"fit" makes each page the size of its image; "a4" and "letter" centre the image on a standard page.'),
+        margin: z.number().min(0).max(144).default(0).describe("Margin in points (72 = 1 inch)."),
+        output
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ inputs, page_size, margin, output: out }) => guard(void 0, async () => {
+      const images = await Promise.all(
+        inputs.map(async (p) => {
+          const bytes2 = await read(p);
+          const kind = sniffFormat(bytes2);
+          if (kind === "jpeg") return { kind: "jpg", bytes: bytes2 };
+          if (kind === "png") return { kind: "png", bytes: bytes2 };
+          throw new Error(`${abs(p)} is not a JPG or PNG. Convert it first, for example at ${SITE}/tools/image-to-pdf, which also takes HEIC and WebP and runs in the browser.`);
+        })
+      );
+      const bytes = await imagesToPdf(images, { pageSize: page_size, orientation: "auto", margin });
+      const dest = await outPath(out, inputs[0], "images", ".pdf");
+      await save(dest, bytes);
+      return ok(`Wrote ${dest} (${plural(images.length, "page")}, ${size(bytes.length)}).`, { output: dest, pages: images.length, bytes: bytes.length });
+    })
+  );
+  const describe = (s) => [
+    `Metadata found: ${s.kinds.length ? s.kinds.join(", ") : "none"} (${size(s.bytes)} removable).`,
+    `GPS location: ${s.hasGps ? "yes" : "no"}.`,
+    ...s.make || s.model ? [`Camera: ${[s.make, s.model].filter(Boolean).join(" ")}.`] : [],
+    ...s.dateTime ? [`Taken: ${s.dateTime}.`] : [],
+    ...s.software ? [`Software: ${s.software}.`] : []
+  ];
+  server.registerTool(
+    "inspect_image_metadata",
+    {
+      title: "Inspect photo metadata",
+      description: "Report the metadata hidden in a JPG, PNG or WebP photo: GPS location, camera make and model, capture time, editing software, and which blocks (EXIF, XMP, IPTC, comments) are present. HEIC files report EXIF only.",
+      inputSchema: { path: z.string().describe("Path to the image.") },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    ({ path }) => guard(void 0, async () => {
+      const bytes = await read(path);
+      if (sniffFormat(bytes) === "unknown") throw new Error(`${abs(path)} is not a JPG, PNG, WebP or HEIC image.`);
+      const s = inspect(bytes);
+      return ok([`${abs(path)}:`, ...describe(s)].join("\n"), { path: abs(path), ...s });
+    })
+  );
+  server.registerTool(
+    "strip_image_metadata",
+    {
+      title: "Remove photo metadata",
+      description: "Write a copy of a JPG, PNG or WebP photo with EXIF (including GPS location), XMP, IPTC and comments removed. Lossless: the image data is not re-encoded. The original file is left untouched.",
+      inputSchema: {
+        input: z.string().describe("Path to the image."),
+        keep_color_profile: z.boolean().default(true).describe("Keep the ICC colour profile so colours look the same. Default true."),
+        output: z.string().optional().describe("Where to write the cleaned copy. Defaults to <name>-clean.<ext> beside the input. Existing files are never overwritten.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    ({ input, keep_color_profile, output: out }) => guard(void 0, async () => {
+      const src = await read(input);
+      const format = sniffFormat(src);
+      if (format === "unknown" || format === "heif") throw new Error(`${abs(input)} is not a JPG, PNG or WebP image. For HEIC photos, convert to JPG first (${SITE}/tools/heic-to-jpg drops the metadata by default).`);
+      const { bytes, summary } = strip(src, { keepIcc: keep_color_profile });
+      const dest = await outPath(out, input, "clean", extname(input) || (format === "jpeg" ? ".jpg" : `.${format}`));
+      await save(dest, bytes);
+      return ok([`Wrote ${dest} (${size(bytes.length)}). The original had:`, ...describe(summary)].join("\n"), { output: dest, bytes: bytes.length, removed: summary });
+    })
+  );
+  return server;
+}
+
+// src/index.ts
+if (process.argv.includes("--version")) {
+  console.log(VERSION);
+  process.exit(0);
+}
+await createServer().connect(new StdioServerTransport());

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "stayput-mcp",
+  "version": "0.1.0",
+  "description": "Local MCP server for PDF and photo tasks: merge, split, rotate, number, images to PDF, inspect and strip photo metadata. Files never leave your machine.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://stayput.dev/mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/keenanlk/stayput.git",
+    "directory": "mcp"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "pdf",
+    "merge-pdf",
+    "exif",
+    "privacy",
+    "local"
+  ],
+  "mcpName": "io.github.keenanlk/stayput",
+  "bin": {
+    "stayput-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "prepublishOnly": "node build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@neslinesli93/qpdf-wasm": "^0.3.0",
+    "pdf-lib": "^1.17.1",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.2",
+    "esbuild": "^0.28.2",
+    "typescript": "^7.0.2"
+  }
+}