@papermark/mcp-server 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1072 @@
+#!/usr/bin/env node
+import {
+  addDocumentVersionContract,
+  attachDataroomDocumentContract,
+  createDataroomContract,
+  createDataroomFolderContract,
+  createFolderContract,
+  createLinkContract,
+  deleteDataroomContract,
+  deleteDataroomFolderContract,
+  deleteDocumentContract,
+  deleteFolderContract,
+  deleteLinkContract,
+  getDataroomAnalyticsContract,
+  getDataroomContract,
+  getDataroomFolderContract,
+  getDocumentAnalyticsContract,
+  getDocumentContract,
+  getDocumentVersionContract,
+  getFolderContract,
+  getLinkAnalyticsContract,
+  getLinkContract,
+  getViewAnalyticsContract,
+  getVisitorContract,
+  listDataroomDocumentsContract,
+  listDataroomFoldersContract,
+  listDataroomsContract,
+  listDocumentVersionsContract,
+  listDocumentsContract,
+  listFoldersContract,
+  listLinkViewsContract,
+  listLinksContract,
+  listVisitorViewsContract,
+  listVisitorsContract,
+  moveDataroomFolderContract,
+  moveFolderContract,
+  promoteDocumentVersionContract,
+  searchDataroomsContract,
+  searchDocumentsContract,
+  updateDataroomContract,
+  updateDataroomFolderContract,
+  updateDocumentContract,
+  updateFolderContract,
+  updateLinkContract
+} from "./chunk-S3ALJ4YG.js";
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools.ts
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+import { lookup as lookupMimeType } from "mime-types";
+import { z } from "zod";
+
+// src/config.ts
+var DEFAULT_API_URL = "https://api.papermark.com";
+function getToken() {
+  return process.env.PAPERMARK_TOKEN?.trim() || void 0;
+}
+function getApiUrl() {
+  return process.env.PAPERMARK_API_URL?.trim() || DEFAULT_API_URL;
+}
+
+// src/client.ts
+var ApiError = class extends Error {
+  code;
+  status;
+  docUrl;
+  details;
+  constructor(status, body) {
+    const message = typeof body === "string" ? body : body.message;
+    super(message);
+    this.status = status;
+    if (typeof body === "string") {
+      this.code = "unknown";
+    } else {
+      this.code = body.code;
+      this.docUrl = body.doc_url;
+      this.details = body.details;
+    }
+  }
+};
+var AuthRequiredError = class extends Error {
+  constructor() {
+    super(
+      "No API token configured. Set PAPERMARK_TOKEN in the MCP server env (get one from papermark.com/settings/tokens)."
+    );
+    this.name = "AuthRequiredError";
+  }
+};
+var NetworkError = class extends Error {
+  url;
+  cause;
+  constructor(url, cause) {
+    const reason = extractNetworkReason(cause);
+    super(`Network request to ${url} failed: ${reason}`);
+    this.name = "NetworkError";
+    this.url = url;
+    this.cause = cause;
+  }
+};
+function extractNetworkReason(err) {
+  if (err && typeof err === "object" && "cause" in err) {
+    const c = err.cause;
+    if (c && typeof c === "object") {
+      const code = c.code;
+      const msg = c.message;
+      if (code || msg) return `${code ?? ""}${code && msg ? " \u2014 " : ""}${msg ?? ""}`.trim();
+    }
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+var DEFAULT_TIMEOUT_MS = 6e4;
+function buildUrl(path, query) {
+  const base = getApiUrl().replace(/\/$/, "");
+  let fullPath = path.startsWith("/") ? path : `/${path}`;
+  if (base.endsWith("/api") && fullPath.startsWith("/api/")) {
+    fullPath = fullPath.slice(4);
+  }
+  const url = new URL(base + fullPath);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== null && v !== "") {
+        url.searchParams.set(k, String(v));
+      }
+    }
+  }
+  return url.toString();
+}
+async function request(path, opts = {}) {
+  const headers = {
+    Accept: "application/json",
+    ...opts.headers ?? {}
+  };
+  if (!opts.anonymous) {
+    const token = opts.token ?? getToken();
+    if (!token) throw new AuthRequiredError();
+    headers.Authorization = `Bearer ${token}`;
+  }
+  let body;
+  if (opts.body !== void 0) {
+    if (opts.body instanceof Uint8Array || opts.body instanceof ArrayBuffer) {
+      body = opts.body;
+    } else {
+      body = JSON.stringify(opts.body);
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const url = buildUrl(path, opts.query);
+  const controller = new AbortController();
+  const timeoutMs = opts.timeout ?? DEFAULT_TIMEOUT_MS;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: opts.method ?? (opts.body ? "POST" : "GET"),
+      headers,
+      body,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (controller.signal.aborted || err instanceof Error && err.name === "AbortError") {
+      throw new NetworkError(
+        url,
+        new Error(`Request exceeded ${timeoutMs}ms timeout`)
+      );
+    }
+    throw new NetworkError(url, err);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (res.status === 204) return void 0;
+  const text = await res.text();
+  const parsed = text ? safeParseJson(text) : null;
+  if (!res.ok) {
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      throw new ApiError(res.status, parsed.error);
+    }
+    const looksLikeHtml = text.trimStart().toLowerCase().startsWith("<");
+    const msg = looksLikeHtml ? `HTTP ${res.status} (server returned HTML, not JSON \u2014 is the API reachable?)` : text || `HTTP ${res.status}`;
+    throw new ApiError(res.status, msg);
+  }
+  return parsed ?? void 0;
+}
+function safeParseJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+var api = {
+  // Documents
+  listDocuments: (query, token) => request("/v1/documents", { query, token }),
+  getDocument: (id, token) => request(`/v1/documents/${id}`, { token }),
+  searchDocuments: (q, limit, token) => request("/v1/documents/search", { query: { q, limit }, token }),
+  updateDocument: (id, body, token) => request(`/v1/documents/${id}`, {
+    method: "PATCH",
+    body,
+    token
+  }),
+  deleteDocument: (id, token) => request(`/v1/documents/${id}`, { method: "DELETE", token }),
+  uploadUrl: (body, token) => request("/v1/documents/upload-url", {
+    method: "POST",
+    body,
+    token
+  }),
+  createDocument: (body, token) => request("/v1/documents", { method: "POST", body, token }),
+  // Document versions
+  listDocumentVersions: (id, token) => request(`/v1/documents/${id}/versions`, { token }),
+  addDocumentVersion: (id, body, token) => request(`/v1/documents/${id}/versions`, {
+    method: "POST",
+    body,
+    token
+  }),
+  getDocumentVersion: (id, vid, token) => request(`/v1/documents/${id}/versions/${vid}`, {
+    token
+  }),
+  promoteDocumentVersion: (id, vid, token) => request(`/v1/documents/${id}/versions/${vid}`, {
+    method: "PATCH",
+    body: { is_primary: true },
+    token
+  }),
+  // Folders
+  listFolders: (query, token) => request("/v1/folders", { query, token }),
+  createFolder: (body, token) => request("/v1/folders", { method: "POST", body, token }),
+  getFolder: (id, token) => request(`/v1/folders/${id}`, { token }),
+  updateFolder: (id, body, token) => request(`/v1/folders/${id}`, { method: "PATCH", body, token }),
+  deleteFolder: (id, opts, token) => request(`/v1/folders/${id}`, {
+    method: "DELETE",
+    query: opts?.cascade ? { cascade: "true" } : void 0,
+    token
+  }),
+  moveFolder: (id, body, token) => request(`/v1/folders/${id}/move`, {
+    method: "POST",
+    body,
+    token
+  }),
+  // Links
+  listLinks: (query, token) => request("/v1/links", { query, token }),
+  getLink: (id, token) => request(`/v1/links/${id}`, { token }),
+  createLink: (body, token) => request("/v1/links", { method: "POST", body, token }),
+  updateLink: (id, body, token) => request(`/v1/links/${id}`, { method: "PATCH", body, token }),
+  deleteLink: (id, token) => request(`/v1/links/${id}`, { method: "DELETE", token }),
+  listViews: (linkId, query, token) => request(`/v1/links/${linkId}/views`, { query, token }),
+  // Datarooms
+  listDatarooms: (query, token) => request("/v1/datarooms", { query, token }),
+  getDataroom: (id, token) => request(`/v1/datarooms/${id}`, { token }),
+  createDataroom: (body, token) => request("/v1/datarooms", { method: "POST", body, token }),
+  updateDataroom: (id, body, token) => request(`/v1/datarooms/${id}`, { method: "PATCH", body, token }),
+  deleteDataroom: (id, token) => request(`/v1/datarooms/${id}`, { method: "DELETE", token }),
+  listDataroomDocuments: (id, query, token) => request(`/v1/datarooms/${id}/documents`, { query, token }),
+  attachDataroomDocument: (id, body, token) => request(`/v1/datarooms/${id}/documents`, {
+    method: "POST",
+    body,
+    token
+  }),
+  // Dataroom folders
+  listDataroomFolders: (id, query, token) => request(`/v1/datarooms/${id}/folders`, {
+    query,
+    token
+  }),
+  createDataroomFolder: (id, body, token) => request(`/v1/datarooms/${id}/folders`, {
+    method: "POST",
+    body,
+    token
+  }),
+  getDataroomFolder: (id, fid, token) => request(`/v1/datarooms/${id}/folders/${fid}`, {
+    token
+  }),
+  updateDataroomFolder: (id, fid, body, token) => request(`/v1/datarooms/${id}/folders/${fid}`, {
+    method: "PATCH",
+    body,
+    token
+  }),
+  deleteDataroomFolder: (id, fid, opts, token) => request(`/v1/datarooms/${id}/folders/${fid}`, {
+    method: "DELETE",
+    query: opts?.cascade ? { cascade: "true" } : void 0,
+    token
+  }),
+  moveDataroomFolder: (id, fid, body, token) => request(`/v1/datarooms/${id}/folders/${fid}/move`, {
+    method: "POST",
+    body,
+    token
+  }),
+  // Visitors
+  listVisitors: (query, token) => request("/v1/visitors", { query, token }),
+  getVisitor: (id, token) => request(`/v1/visitors/${id}`, { token }),
+  listVisitorViews: (id, query, token) => request(`/v1/visitors/${id}/views`, { query, token }),
+  // Analytics
+  documentAnalytics: (id, query, token) => request(`/v1/analytics/documents/${id}`, { query, token }),
+  linkAnalytics: (id, query, token) => request(`/v1/analytics/links/${id}`, { query, token }),
+  dataroomAnalytics: (id, query, token) => request(`/v1/analytics/datarooms/${id}`, { query, token }),
+  viewAnalytics: (id, token) => request(`/v1/analytics/views/${id}`, { token })
+};
+
+// src/tools.ts
+async function run(fn, label) {
+  try {
+    const result = await fn();
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    if (err instanceof ApiError) {
+      const detail = err.details !== void 0 && err.details !== null ? `
+Details: ${JSON.stringify(err.details)}` : "";
+      const hint = err.docUrl ? `
+Docs: ${err.docUrl}` : "";
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `${label} failed (${err.status} ${err.code}): ${err.message}${detail}${hint}`
+          }
+        ]
+      };
+    }
+    if (err instanceof NetworkError) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `${label} failed: ${err.message}` }]
+      };
+    }
+    if (err instanceof AuthRequiredError) {
+      return { isError: true, content: [{ type: "text", text: err.message }] };
+    }
+    return {
+      isError: true,
+      content: [
+        { type: "text", text: `${label} failed: ${err instanceof Error ? err.message : String(err)}` }
+      ]
+    };
+  }
+}
+function guessContentType(fileName) {
+  return lookupMimeType(fileName) || "application/octet-stream";
+}
+function filenameFromUrl(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    const last = u.pathname.split("/").filter(Boolean).pop();
+    if (!last) return "document";
+    return decodeURIComponent(last);
+  } catch {
+    return "document";
+  }
+}
+function summarizeDocument(d) {
+  return {
+    id: d.id,
+    object: d.object,
+    name: d.name,
+    content_type: d.content_type,
+    num_pages: d.num_pages,
+    created: d.created
+  };
+}
+function summarizeLink(l) {
+  return {
+    id: l.id,
+    object: l.object,
+    url: l.url,
+    name: l.name,
+    target_type: l.target_type,
+    document_id: l.document_id,
+    dataroom_id: l.dataroom_id,
+    expires_at: l.expires_at,
+    is_password_protected: l.is_password_protected,
+    email_protected: l.email_protected,
+    allow_download: l.allow_download
+  };
+}
+function summarizeView(v) {
+  return {
+    id: v.id,
+    link_id: v.link_id,
+    viewer_email: v.viewer_email,
+    viewed_at: v.viewed_at,
+    downloaded_at: v.downloaded_at
+  };
+}
+function registerTools(server) {
+  server.registerTool(
+    listDocumentsContract.name,
+    {
+      title: listDocumentsContract.title,
+      description: listDocumentsContract.description,
+      inputSchema: listDocumentsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDocuments({
+        limit: args.limit,
+        cursor: args.cursor,
+        query: args.query
+      });
+      return {
+        documents: list.data.map(summarizeDocument),
+        next_cursor: list.next_cursor
+      };
+    }, "list_documents")
+  );
+  server.registerTool(
+    getDocumentContract.name,
+    {
+      title: getDocumentContract.title,
+      description: getDocumentContract.description,
+      inputSchema: getDocumentContract.inputSchema
+    },
+    async (args) => run(() => api.getDocument(args.document_id), "get_document")
+  );
+  server.registerTool(
+    searchDocumentsContract.name,
+    {
+      title: searchDocumentsContract.title,
+      description: searchDocumentsContract.description,
+      inputSchema: searchDocumentsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.searchDocuments(args.query, args.limit);
+      return { documents: list.data.map(summarizeDocument), next_cursor: list.next_cursor };
+    }, "search_documents")
+  );
+  server.registerTool(
+    "upload_document",
+    {
+      title: "Upload a document",
+      description: `Upload a document to Papermark from a local file path OR a public HTTPS URL.
+
+WORKFLOW:
+(1) Resolve the source: the user must name either a \`file_path\` (local filesystem \u2014 stdio mode only) OR a \`source_url\` (public HTTPS). Never guess a path; if the user attached a file in chat but didn't give a local path, ASK them to save it and provide the path.
+(2) Confirm the target \`name\` if the user wants something other than the filename.
+(3) If the user wants a share link in the same breath, set \`create_link: true\` \u2014 otherwise follow up with \`create_link\` so you can set password/expiry/email gating explicitly.
+
+Don't upload any file the user didn't explicitly point at. Requires scope \`documents.write\`.`,
+      inputSchema: {
+        file_path: z.string().optional().describe(
+          "Absolute local path \u2014 only works when the MCP server runs on the same machine as the file (stdio mode)"
+        ),
+        source_url: z.string().url().refine((s) => s.startsWith("https://"), {
+          message: "source_url must use https:// (http is rejected by the API)"
+        }).optional().describe("Public HTTPS URL the server should fetch (alternative to file_path)"),
+        name: z.string().optional().describe("Display name; defaults to the filename"),
+        content_type: z.string().optional().describe("MIME type; inferred from extension when omitted"),
+        folder_id: z.string().optional().describe(
+          "Destination folder id (created beforehand via `create_folder`). Omit for the team-library root."
+        ),
+        create_link: z.boolean().optional().describe("Create a default share link after upload")
+      }
+    },
+    async (args) => run(async () => {
+      if (!args.file_path && !args.source_url) {
+        throw new Error("Provide either file_path (local) or source_url (remote).");
+      }
+      if (args.file_path && args.source_url) {
+        throw new Error("Provide only one of file_path or source_url.");
+      }
+      if (args.source_url) {
+        const name = args.name ?? filenameFromUrl(args.source_url);
+        const doc2 = await api.createDocument({
+          name,
+          source_url: args.source_url,
+          folder_id: args.folder_id,
+          create_link: args.create_link
+        });
+        return { document: summarizeDocument(doc2) };
+      }
+      const filePath = args.file_path;
+      const stats = await stat(filePath);
+      const fileName = basename(filePath);
+      const contentType = args.content_type ?? guessContentType(fileName);
+      const body = await readFile(filePath);
+      const presigned = await api.uploadUrl({
+        fileName,
+        contentType,
+        contentLength: stats.size
+      });
+      const putController = new AbortController();
+      const putTimer = setTimeout(() => putController.abort(), 5 * 6e4);
+      let put;
+      try {
+        put = await fetch(presigned.upload_url, {
+          method: "PUT",
+          headers: presigned.required_headers,
+          body,
+          signal: putController.signal
+        });
+      } catch (err) {
+        if (putController.signal.aborted || err instanceof Error && err.name === "AbortError") {
+          throw new Error(
+            "Storage PUT aborted: presigned upload exceeded 5 minute timeout. The connection to object storage stalled \u2014 retry with a smaller file or a faster network."
+          );
+        }
+        throw err;
+      } finally {
+        clearTimeout(putTimer);
+      }
+      if (!put.ok) {
+        throw new Error(`Storage PUT failed: HTTP ${put.status} ${put.statusText}`);
+      }
+      const doc = await api.createDocument({
+        name: args.name ?? fileName,
+        upload_id: presigned.upload_id,
+        folder_id: args.folder_id,
+        create_link: args.create_link
+      });
+      return { document: summarizeDocument(doc) };
+    }, "upload_document")
+  );
+  server.registerTool(
+    createLinkContract.name,
+    {
+      title: createLinkContract.title,
+      description: createLinkContract.description,
+      inputSchema: createLinkContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const hasDoc = Boolean(args.document_id);
+      const hasDr = Boolean(args.dataroom_id);
+      if (!hasDoc && !hasDr) {
+        throw new Error("Provide document_id or dataroom_id.");
+      }
+      if (hasDoc && hasDr) {
+        throw new Error(
+          "Provide exactly one of document_id or dataroom_id, not both."
+        );
+      }
+      const link = await api.createLink(args);
+      return { link: summarizeLink(link) };
+    }, "create_link")
+  );
+  server.registerTool(
+    listLinksContract.name,
+    {
+      title: listLinksContract.title,
+      description: listLinksContract.description,
+      inputSchema: listLinksContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listLinks(args);
+      return { links: list.data.map(summarizeLink), next_cursor: list.next_cursor };
+    }, "list_links")
+  );
+  server.registerTool(
+    listLinkViewsContract.name,
+    {
+      title: listLinkViewsContract.title,
+      description: listLinkViewsContract.description,
+      inputSchema: listLinkViewsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listViews(args.link_id, {
+        limit: args.limit,
+        cursor: args.cursor
+      });
+      return { views: list.data.map(summarizeView), next_cursor: list.next_cursor };
+    }, "list_link_views")
+  );
+  server.registerTool(
+    listDataroomsContract.name,
+    {
+      title: listDataroomsContract.title,
+      description: listDataroomsContract.description,
+      inputSchema: listDataroomsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDatarooms(args);
+      return { datarooms: list.data, next_cursor: list.next_cursor };
+    }, "list_datarooms")
+  );
+  server.registerTool(
+    searchDataroomsContract.name,
+    {
+      title: searchDataroomsContract.title,
+      description: searchDataroomsContract.description,
+      inputSchema: searchDataroomsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDatarooms({
+        query: args.query,
+        limit: args.limit ?? 10
+      });
+      return { datarooms: list.data, next_cursor: list.next_cursor };
+    }, "search_datarooms")
+  );
+  server.registerTool(
+    getDataroomContract.name,
+    {
+      title: getDataroomContract.title,
+      description: getDataroomContract.description,
+      inputSchema: getDataroomContract.inputSchema
+    },
+    async (args) => run(() => api.getDataroom(args.dataroom_id), "get_dataroom")
+  );
+  server.registerTool(
+    createDataroomContract.name,
+    {
+      title: createDataroomContract.title,
+      description: createDataroomContract.description,
+      inputSchema: createDataroomContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const dr = await api.createDataroom(args);
+      return { dataroom: dr };
+    }, "create_dataroom")
+  );
+  server.registerTool(
+    listDataroomDocumentsContract.name,
+    {
+      title: listDataroomDocumentsContract.title,
+      description: listDataroomDocumentsContract.description,
+      inputSchema: listDataroomDocumentsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDataroomDocuments(args.dataroom_id, {
+        limit: args.limit,
+        cursor: args.cursor,
+        folder_id: args.folder_id
+      });
+      return { documents: list.data, next_cursor: list.next_cursor };
+    }, "list_dataroom_documents")
+  );
+  server.registerTool(
+    listVisitorsContract.name,
+    {
+      title: listVisitorsContract.title,
+      description: listVisitorsContract.description,
+      inputSchema: listVisitorsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listVisitors(args);
+      return { visitors: list.data, next_cursor: list.next_cursor };
+    }, "list_visitors")
+  );
+  server.registerTool(
+    listVisitorViewsContract.name,
+    {
+      title: listVisitorViewsContract.title,
+      description: listVisitorViewsContract.description,
+      inputSchema: listVisitorViewsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listVisitorViews(args.visitor_id, {
+        limit: args.limit,
+        cursor: args.cursor
+      });
+      return { views: list.data, next_cursor: list.next_cursor };
+    }, "list_visitor_views")
+  );
+  server.registerTool(
+    getDocumentAnalyticsContract.name,
+    {
+      title: getDocumentAnalyticsContract.title,
+      description: getDocumentAnalyticsContract.description,
+      inputSchema: getDocumentAnalyticsContract.inputSchema
+    },
+    async (args) => run(
+      () => api.documentAnalytics(args.document_id, {
+        since: args.since,
+        until: args.until
+      }),
+      "get_document_analytics"
+    )
+  );
+  server.registerTool(
+    getLinkAnalyticsContract.name,
+    {
+      title: getLinkAnalyticsContract.title,
+      description: getLinkAnalyticsContract.description,
+      inputSchema: getLinkAnalyticsContract.inputSchema
+    },
+    async (args) => run(
+      () => api.linkAnalytics(args.link_id, {
+        since: args.since,
+        until: args.until
+      }),
+      "get_link_analytics"
+    )
+  );
+  server.registerTool(
+    getDataroomAnalyticsContract.name,
+    {
+      title: getDataroomAnalyticsContract.title,
+      description: getDataroomAnalyticsContract.description,
+      inputSchema: getDataroomAnalyticsContract.inputSchema
+    },
+    async (args) => run(
+      () => api.dataroomAnalytics(args.dataroom_id, {
+        since: args.since,
+        until: args.until
+      }),
+      "get_dataroom_analytics"
+    )
+  );
+  server.registerTool(
+    getViewAnalyticsContract.name,
+    {
+      title: getViewAnalyticsContract.title,
+      description: getViewAnalyticsContract.description,
+      inputSchema: getViewAnalyticsContract.inputSchema
+    },
+    async (args) => run(() => api.viewAnalytics(args.view_id), "get_view_analytics")
+  );
+  server.registerTool(
+    updateDocumentContract.name,
+    {
+      title: updateDocumentContract.title,
+      description: updateDocumentContract.description,
+      inputSchema: updateDocumentContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const body = {};
+      if (args.name !== void 0) body.name = args.name;
+      if (args.folder_id !== void 0) body.folder_id = args.folder_id;
+      if (Object.keys(body).length === 0) {
+        throw new Error("Provide at least one of `name` or `folder_id`.");
+      }
+      const doc = await api.updateDocument(args.document_id, body);
+      return { document: summarizeDocument(doc) };
+    }, "update_document")
+  );
+  server.registerTool(
+    deleteDocumentContract.name,
+    {
+      title: deleteDocumentContract.title,
+      description: deleteDocumentContract.description,
+      inputSchema: deleteDocumentContract.inputSchema
+    },
+    async (args) => run(async () => {
+      return await api.deleteDocument(args.document_id);
+    }, "delete_document")
+  );
+  server.registerTool(
+    listDocumentVersionsContract.name,
+    {
+      title: listDocumentVersionsContract.title,
+      description: listDocumentVersionsContract.description,
+      inputSchema: listDocumentVersionsContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDocumentVersions(args.document_id);
+      return { versions: list.data };
+    }, "list_document_versions")
+  );
+  server.registerTool(
+    getDocumentVersionContract.name,
+    {
+      title: getDocumentVersionContract.title,
+      description: getDocumentVersionContract.description,
+      inputSchema: getDocumentVersionContract.inputSchema
+    },
+    async (args) => run(
+      () => api.getDocumentVersion(args.document_id, args.version_id),
+      "get_document_version"
+    )
+  );
+  server.registerTool(
+    addDocumentVersionContract.name,
+    {
+      title: addDocumentVersionContract.title,
+      description: addDocumentVersionContract.description,
+      inputSchema: addDocumentVersionContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const v = await api.addDocumentVersion(args.document_id, {
+        source_url: args.source_url
+      });
+      return { version: v };
+    }, "add_document_version")
+  );
+  server.registerTool(
+    promoteDocumentVersionContract.name,
+    {
+      title: promoteDocumentVersionContract.title,
+      description: promoteDocumentVersionContract.description,
+      inputSchema: promoteDocumentVersionContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const v = await api.promoteDocumentVersion(
+        args.document_id,
+        args.version_id
+      );
+      return { version: v };
+    }, "promote_document_version")
+  );
+  server.registerTool(
+    listFoldersContract.name,
+    {
+      title: listFoldersContract.title,
+      description: listFoldersContract.description,
+      inputSchema: listFoldersContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listFolders(args);
+      return { folders: list.data, next_cursor: list.next_cursor };
+    }, "list_folders")
+  );
+  server.registerTool(
+    getFolderContract.name,
+    {
+      title: getFolderContract.title,
+      description: getFolderContract.description,
+      inputSchema: getFolderContract.inputSchema
+    },
+    async (args) => run(() => api.getFolder(args.folder_id), "get_folder")
+  );
+  server.registerTool(
+    createFolderContract.name,
+    {
+      title: createFolderContract.title,
+      description: createFolderContract.description,
+      inputSchema: createFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const f = await api.createFolder(args);
+      return { folder: f };
+    }, "create_folder")
+  );
+  server.registerTool(
+    updateFolderContract.name,
+    {
+      title: updateFolderContract.title,
+      description: updateFolderContract.description,
+      inputSchema: updateFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const body = {};
+      if (args.name !== void 0) body.name = args.name;
+      if (args.icon !== void 0) body.icon = args.icon;
+      if (args.color !== void 0) body.color = args.color;
+      if (Object.keys(body).length === 0) {
+        throw new Error("Provide at least one of `name`, `icon`, `color`.");
+      }
+      const f = await api.updateFolder(args.folder_id, body);
+      return { folder: f };
+    }, "update_folder")
+  );
+  server.registerTool(
+    deleteFolderContract.name,
+    {
+      title: deleteFolderContract.title,
+      description: deleteFolderContract.description,
+      inputSchema: deleteFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      return await api.deleteFolder(args.folder_id, {
+        cascade: args.cascade
+      });
+    }, "delete_folder")
+  );
+  server.registerTool(
+    moveFolderContract.name,
+    {
+      title: moveFolderContract.title,
+      description: moveFolderContract.description,
+      inputSchema: moveFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const f = await api.moveFolder(args.folder_id, {
+        parent_id: args.parent_id
+      });
+      return { folder: f };
+    }, "move_folder")
+  );
+  server.registerTool(
+    getLinkContract.name,
+    {
+      title: getLinkContract.title,
+      description: getLinkContract.description,
+      inputSchema: getLinkContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const link = await api.getLink(args.link_id);
+      return { link: summarizeLink(link) };
+    }, "get_link")
+  );
+  server.registerTool(
+    updateLinkContract.name,
+    {
+      title: updateLinkContract.title,
+      description: updateLinkContract.description,
+      inputSchema: updateLinkContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const { link_id, ...rest } = args;
+      if (Object.keys(rest).length === 0) {
+        throw new Error("Provide at least one field to update.");
+      }
+      const link = await api.updateLink(link_id, rest);
+      return { link: summarizeLink(link) };
+    }, "update_link")
+  );
+  server.registerTool(
+    deleteLinkContract.name,
+    {
+      title: deleteLinkContract.title,
+      description: deleteLinkContract.description,
+      inputSchema: deleteLinkContract.inputSchema
+    },
+    async (args) => run(async () => {
+      return await api.deleteLink(args.link_id);
+    }, "delete_link")
+  );
+  server.registerTool(
+    updateDataroomContract.name,
+    {
+      title: updateDataroomContract.title,
+      description: updateDataroomContract.description,
+      inputSchema: updateDataroomContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const { dataroom_id, ...rest } = args;
+      if (Object.keys(rest).length === 0) {
+        throw new Error("Provide at least one field to update.");
+      }
+      const dr = await api.updateDataroom(dataroom_id, rest);
+      return { dataroom: dr };
+    }, "update_dataroom")
+  );
+  server.registerTool(
+    deleteDataroomContract.name,
+    {
+      title: deleteDataroomContract.title,
+      description: deleteDataroomContract.description,
+      inputSchema: deleteDataroomContract.inputSchema
+    },
+    async (args) => run(async () => {
+      return await api.deleteDataroom(args.dataroom_id);
+    }, "delete_dataroom")
+  );
+  server.registerTool(
+    attachDataroomDocumentContract.name,
+    {
+      title: attachDataroomDocumentContract.title,
+      description: attachDataroomDocumentContract.description,
+      inputSchema: attachDataroomDocumentContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const item = await api.attachDataroomDocument(args.dataroom_id, {
+        document_id: args.document_id,
+        folder_id: args.folder_id
+      });
+      return { item };
+    }, "attach_dataroom_document")
+  );
+  server.registerTool(
+    listDataroomFoldersContract.name,
+    {
+      title: listDataroomFoldersContract.title,
+      description: listDataroomFoldersContract.description,
+      inputSchema: listDataroomFoldersContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const list = await api.listDataroomFolders(args.dataroom_id, {
+        parent_id: args.parent_id,
+        limit: args.limit,
+        cursor: args.cursor
+      });
+      return { folders: list.data, next_cursor: list.next_cursor };
+    }, "list_dataroom_folders")
+  );
+  server.registerTool(
+    getDataroomFolderContract.name,
+    {
+      title: getDataroomFolderContract.title,
+      description: getDataroomFolderContract.description,
+      inputSchema: getDataroomFolderContract.inputSchema
+    },
+    async (args) => run(
+      () => api.getDataroomFolder(args.dataroom_id, args.folder_id),
+      "get_dataroom_folder"
+    )
+  );
+  server.registerTool(
+    createDataroomFolderContract.name,
+    {
+      title: createDataroomFolderContract.title,
+      description: createDataroomFolderContract.description,
+      inputSchema: createDataroomFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const { dataroom_id, ...body } = args;
+      const f = await api.createDataroomFolder(dataroom_id, body);
+      return { folder: f };
+    }, "create_dataroom_folder")
+  );
+  server.registerTool(
+    updateDataroomFolderContract.name,
+    {
+      title: updateDataroomFolderContract.title,
+      description: updateDataroomFolderContract.description,
+      inputSchema: updateDataroomFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const body = {};
+      if (args.name !== void 0) body.name = args.name;
+      if (args.icon !== void 0) body.icon = args.icon;
+      if (args.color !== void 0) body.color = args.color;
+      if (Object.keys(body).length === 0) {
+        throw new Error("Provide at least one of `name`, `icon`, `color`.");
+      }
+      const f = await api.updateDataroomFolder(
+        args.dataroom_id,
+        args.folder_id,
+        body
+      );
+      return { folder: f };
+    }, "update_dataroom_folder")
+  );
+  server.registerTool(
+    deleteDataroomFolderContract.name,
+    {
+      title: deleteDataroomFolderContract.title,
+      description: deleteDataroomFolderContract.description,
+      inputSchema: deleteDataroomFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      return await api.deleteDataroomFolder(
+        args.dataroom_id,
+        args.folder_id,
+        { cascade: args.cascade }
+      );
+    }, "delete_dataroom_folder")
+  );
+  server.registerTool(
+    moveDataroomFolderContract.name,
+    {
+      title: moveDataroomFolderContract.title,
+      description: moveDataroomFolderContract.description,
+      inputSchema: moveDataroomFolderContract.inputSchema
+    },
+    async (args) => run(async () => {
+      const f = await api.moveDataroomFolder(
+        args.dataroom_id,
+        args.folder_id,
+        { parent_id: args.parent_id }
+      );
+      return { folder: f };
+    }, "move_dataroom_folder")
+  );
+  server.registerTool(
+    getVisitorContract.name,
+    {
+      title: getVisitorContract.title,
+      description: getVisitorContract.description,
+      inputSchema: getVisitorContract.inputSchema
+    },
+    async (args) => run(() => api.getVisitor(args.visitor_id), "get_visitor")
+  );
+}
+
+// src/index.ts
+var SERVER_INFO = {
+  name: "papermark-mcp",
+  version: "0.1.0"
+};
+async function main() {
+  const server = new McpServer(SERVER_INFO, { capabilities: { tools: {} } });
+  registerTools(server);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(
+    `[papermark-mcp] fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map