filetopdf-mcp 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# FileToPDF MCP server
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server for
+[FileToPDF](https://filetopdf.dev). It lets any MCP client — Claude Desktop, Cursor,
+Cline, VS Code, or your own agent — convert **files, HTML, and Markdown to PDF**
+through natural language. **Bring your own API key** (free trial key on the home page).
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `get_account` | Check the API key and show plan + remaining credits. Free, no credits used. |
+| `convert_file` | Convert a file from a **public URL** (DOCX, XLSX, PPTX, images, HTML, MD, PDF…) to PDF. |
+| `convert_html` | Render a raw **HTML** string (with optional CSS + layout options) to PDF. |
+| `convert_markdown` | Render a raw **Markdown** string (with optional CSS + layout options) to PDF. |
+
+Each convert tool returns a metadata summary **and** the PDF as an embedded
+`application/pdf` resource (base64), so capable clients can save the file. Set the
+`FILETOPDF_OUTPUT_DIR` env var, or pass `save_path`, to also write the PDF to disk.
+
+Conversion options (`landscape`, `paperWidth/Height`, margins, `scale`, `pdfa`,
+passwords, …) are available on **Pro, Scale, and the free trial**; on Starter/Basic
+they return an upgrade error. Each successful conversion costs **1 credit**; errors
+are free.
+
+## Quick start (local / stdio)
+
+```bash
+npx filetopdf-mcp
+```
+
+Add to **Claude Desktop** (`claude_desktop_config.json`) or **Cursor**:
+
+```json
+{
+  "mcpServers": {
+    "filetopdf": {
+      "command": "npx",
+      "args": ["-y", "filetopdf-mcp"],
+      "env": { "FILETOPDF_API_KEY": "sk_live_xxxxxxxxxxxxxxxxxxxxxxxx" }
+    }
+  }
+}
+```
+
+Get a key free at <https://filetopdf.dev> (instant trial key on the home page, 10 free
+conversions) or from the dashboard.
+
+## Hosted / remote (Streamable HTTP)
+
+```bash
+npm run build && npm run start:http   # listens on $PORT (default 8080) at /mcp
+```
+
+The key is read from the `x-api-key` header, an `Authorization: Bearer` header, or an
+`?apiKey=` query parameter — so one endpoint serves every user with their own key.
+A `Dockerfile` is included for container hosting (Smithery, Fly, Render, Cloud Run).
+
+## Develop & test
+
+```bash
+npm install
+npm run build          # tsc -> dist/
+npm test               # spawns the built stdio server, runs a live conversion
+```
+
+`npm test` reads `FILETOPDF_API_KEY`, or `API_KEY=` from a gitignored `.env`.
+
+## Publishing & listing
+
+This server is built to be **publicly discoverable** on MCP marketplaces:
+
+1. **npm** — `npm publish` makes `npx filetopdf-mcp` work (prerequisite for most
+   directories).
+2. **GitHub** — push a public repo (`filetopdf/filetopdf-mcp`); Glama and others
+   auto-index it.
+3. **Smithery** — connect the repo at <https://smithery.ai/new>; it builds the
+   `Dockerfile` and hosts the HTTP server using `smithery.yaml`.
+4. **Official MCP Registry** — publish `server.json` with the `mcp-publisher` CLI
+   (namespace `dev.filetopdf/*` is verified via a DNS TXT record on filetopdf.dev).
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,36 @@
+export declare const BASE_URL: string;
+export declare const OPTION_KEYS: readonly ["landscape", "nativePageRanges", "pdfa", "pdfua", "password", "userPassword", "ownerPassword", "paperWidth", "paperHeight", "marginTop", "marginBottom", "marginLeft", "marginRight", "scale", "printBackground", "preferCssPageSize"];
+export type RawOptions = Record<string, unknown>;
+export declare function stringifyOptions(input: RawOptions): Record<string, string>;
+export interface AccountData {
+    workspace_id: string;
+    plan: string;
+    credits_remaining: number;
+    subscription_status: string;
+}
+export interface PdfResult {
+    pdfBase64: string;
+    filename: string;
+    pages: number | null;
+    sizeBytes: number;
+    creditsUsed: number | null;
+    creditsRemaining: number | null;
+}
+/** A FileToPDF API error carrying the stable machine code and any extra fields. */
+export declare class FileToPdfError extends Error {
+    code: string;
+    httpStatus: number;
+    parameter?: string;
+    upgradeUrl?: string;
+    constructor(message: string, opts: {
+        code: string;
+        httpStatus: number;
+        parameter?: string;
+        upgradeUrl?: string;
+    });
+}
+/** GET /account — free, never rate-limited. Use it as the connection/credits check. */
+export declare function getAccount(apiKey: string): Promise<AccountData>;
+export declare function convertFile(apiKey: string, url: string, options?: RawOptions): Promise<PdfResult>;
+export declare function convertHtml(apiKey: string, html: string, css: string | undefined, options?: RawOptions): Promise<PdfResult>;
+export declare function convertMarkdown(apiKey: string, markdown: string, css: string | undefined, options?: RawOptions): Promise<PdfResult>;

package/dist/api.js

@@ -0,0 +1,150 @@
+// FileToPDF API client — a thin, dependency-free wrapper around the three
+// conversion endpoints plus the free /account check. Shared by every MCP tool.
+//
+// API contract (see integrations/openapi/openapi.yaml for the source of truth):
+//   POST /file      { url, ...options }        -> PDF
+//   POST /html      { html, css?, ...options } -> PDF
+//   POST /markdown  { markdown, css?, ...options } -> PDF
+//   GET  /account                              -> { status, data:{ plan, credits_remaining, ... } }
+// Auth: header `x-api-key: sk_live_...`. Errors never cost credits.
+export const BASE_URL = process.env.FILETOPDF_BASE_URL || "https://api.filetopdf.dev";
+// Layout/render options forwarded to the API. The backend's form handling expects
+// STRINGS, so booleans become "true"/"false" and numbers their string form.
+// IMPORTANT: only send options the user actually set — any option on a Starter/Basic
+// plan returns 402 upgrade_required, so `false` booleans and empty values are DROPPED.
+export const OPTION_KEYS = [
+    "landscape",
+    "nativePageRanges",
+    "pdfa",
+    "pdfua",
+    "password",
+    "userPassword",
+    "ownerPassword",
+    "paperWidth",
+    "paperHeight",
+    "marginTop",
+    "marginBottom",
+    "marginLeft",
+    "marginRight",
+    "scale",
+    "printBackground",
+    "preferCssPageSize",
+];
+export function stringifyOptions(input) {
+    const out = {};
+    for (const key of OPTION_KEYS) {
+        let v = input[key];
+        if (v === undefined || v === null || v === "")
+            continue;
+        if (typeof v === "boolean") {
+            if (!v)
+                continue; // drop false — never send an option the user didn't enable
+            v = "true";
+        }
+        out[key] = String(v);
+    }
+    return out;
+}
+/** A FileToPDF API error carrying the stable machine code and any extra fields. */
+export class FileToPdfError extends Error {
+    code;
+    httpStatus;
+    parameter;
+    upgradeUrl;
+    constructor(message, opts) {
+        super(message);
+        this.name = "FileToPdfError";
+        this.code = opts.code;
+        this.httpStatus = opts.httpStatus;
+        this.parameter = opts.parameter;
+        this.upgradeUrl = opts.upgradeUrl;
+    }
+}
+function authHeaders(apiKey) {
+    if (!apiKey) {
+        throw new FileToPdfError("No FileToPDF API key configured. Set FILETOPDF_API_KEY (stdio) or send an x-api-key header (HTTP). Get a free key at https://filetopdf.dev.", { code: "missing_api_key", httpStatus: 401 });
+    }
+    return { "x-api-key": apiKey };
+}
+/** Turn a non-OK response into a friendly FileToPdfError, reading the {error:{...}} envelope. */
+async function toError(res) {
+    let code = `http_${res.status}`;
+    let message = `Request failed (HTTP ${res.status}).`;
+    let parameter;
+    let upgradeUrl;
+    try {
+        const body = (await res.json());
+        if (body?.error) {
+            code = body.error.code || code;
+            message = body.error.message || message;
+            parameter = body.error.parameter;
+            upgradeUrl = body.error.upgrade_url;
+        }
+    }
+    catch {
+        /* non-JSON error body — keep the generic message */
+    }
+    // Friendlier guidance for the common plan-gating cases.
+    if (code === "upgrade_required" && parameter) {
+        message = `The "${parameter}" option requires the Pro or Scale plan (or the free trial). ${message}`;
+    }
+    else if (code === "payment_required") {
+        message = `Out of FileToPDF credits. ${message}${upgradeUrl ? ` Upgrade at ${upgradeUrl}.` : ""}`;
+    }
+    else if (code === "forbidden_url") {
+        message = `That URL was rejected (private/internal addresses are not allowed). ${message}`;
+    }
+    else if (code === "concurrency_limit") {
+        message = `Concurrency limit reached for your plan. ${message}`;
+    }
+    return new FileToPdfError(message, { code, httpStatus: res.status, parameter, upgradeUrl });
+}
+/** GET /account — free, never rate-limited. Use it as the connection/credits check. */
+export async function getAccount(apiKey) {
+    const res = await fetch(`${BASE_URL}/account`, {
+        headers: { ...authHeaders(apiKey), Accept: "application/json" },
+    });
+    if (!res.ok)
+        throw await toError(res);
+    const body = (await res.json());
+    if (body?.status !== "success")
+        throw await toError(res);
+    return body.data;
+}
+/** Internal: POST a JSON body to a conversion endpoint and parse the base64 envelope. */
+async function convert(apiKey, path, body) {
+    const res = await fetch(`${BASE_URL}${path}`, {
+        method: "POST",
+        headers: {
+            ...authHeaders(apiKey),
+            "Content-Type": "application/json",
+            // Ask for the JSON envelope so we get base64 + metadata in one shot — easiest
+            // form to hand back to an MCP client as an embedded resource.
+            Accept: "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw await toError(res);
+    const out = (await res.json());
+    if (out?.status !== "success" || !out?.data?.pdf)
+        throw await toError(res);
+    const d = out.data;
+    return {
+        pdfBase64: d.pdf,
+        filename: d.filename || "converted.pdf",
+        pages: typeof d.pages === "number" ? d.pages : null,
+        sizeBytes: typeof d.size_bytes === "number" ? d.size_bytes : 0,
+        creditsUsed: typeof d.credits_used === "number" ? d.credits_used : null,
+        creditsRemaining: typeof d.credits_remaining === "number" ? d.credits_remaining : null,
+    };
+}
+export function convertFile(apiKey, url, options = {}) {
+    return convert(apiKey, "/file", { url, ...stringifyOptions(options) });
+}
+export function convertHtml(apiKey, html, css, options = {}) {
+    return convert(apiKey, "/html", { html, ...(css ? { css } : {}), ...stringifyOptions(options) });
+}
+export function convertMarkdown(apiKey, markdown, css, options = {}) {
+    return convert(apiKey, "/markdown", { markdown, ...(css ? { css } : {}), ...stringifyOptions(options) });
+}

package/dist/http.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http.js

@@ -0,0 +1,101 @@
+// Streamable HTTP entrypoint — the form used for hosted/remote deployment
+// (Smithery, your own infra). Runs stateless: each request spins up a fresh server
+// bound to the API key carried on that request, so one endpoint serves every user
+// with their own key (BYO-key).
+//
+// The FileToPDF API key is read, in order, from:
+//   1. the `x-api-key` request header
+//   2. an `Authorization: Bearer <key>` header
+//   3. an `apiKey` / `api_key` query-string parameter (how Smithery passes config)
+//
+// Listens on PORT (default 8080) at the path /mcp.
+import { createServer as createHttpServer } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer } from "./server.js";
+const PORT = Number(process.env.PORT) || 8080;
+const MCP_PATH = "/mcp";
+function resolveApiKey(req, query) {
+    const headerKey = req.headers["x-api-key"];
+    if (typeof headerKey === "string" && headerKey)
+        return headerKey;
+    const auth = req.headers["authorization"];
+    if (typeof auth === "string" && auth.toLowerCase().startsWith("bearer ")) {
+        return auth.slice(7).trim();
+    }
+    return query.get("apiKey") || query.get("api_key") || undefined;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (c) => chunks.push(Buffer.from(c)));
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if (!raw)
+                return resolve(undefined);
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function setCors(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, x-api-key, Authorization, Mcp-Session-Id");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+}
+const httpServer = createHttpServer(async (req, res) => {
+    setCors(res);
+    if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+    }
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    // Simple health check for hosting platforms.
+    if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/health")) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", server: "filetopdf-mcp" }));
+        return;
+    }
+    if (url.pathname !== MCP_PATH) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found. The MCP endpoint is at /mcp." }));
+        return;
+    }
+    // Stateless: one transport + server per request, no session persistence.
+    if (req.method === "POST") {
+        try {
+            const body = await readBody(req);
+            const apiKey = resolveApiKey(req, url.searchParams);
+            const server = createServer(() => apiKey);
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            res.on("close", () => {
+                transport.close();
+                server.close();
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, body);
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+            }
+            res.end(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: err.message },
+                id: null,
+            }));
+        }
+        return;
+    }
+    // GET/DELETE aren't used in stateless mode.
+    res.writeHead(405, { "Content-Type": "application/json", Allow: "POST, OPTIONS" });
+    res.end(JSON.stringify({ error: "Method not allowed. Use POST for MCP requests." }));
+});
+httpServer.listen(PORT, () => {
+    console.error(`filetopdf-mcp (Streamable HTTP) listening on http://0.0.0.0:${PORT}${MCP_PATH}`);
+});

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** How the active transport resolves the caller's FileToPDF API key. */
+export type ApiKeyResolver = () => string | undefined;
+/**
+ * Create a fully-configured FileToPDF MCP server. The transport supplies a resolver
+ * so each tool call reads the right API key (from env for stdio, from headers for HTTP).
+ */
+export declare function createServer(getApiKey: ApiKeyResolver): McpServer;

package/dist/server.js

@@ -0,0 +1,195 @@
+// FileToPDF MCP server — registers the four tools shared by every transport.
+//
+// Design mirrors the shipped FileToPDF connectors (Make / n8n / Zapier / Apify):
+//   * All actions, zero triggers (the API is pure request/response).
+//   * Clean three-converter split: convert_file (URL) / convert_html / convert_markdown.
+//   * A free get_account tool that doubles as the connection + credits check.
+//   * Layout options forwarded as STRINGS, false/empty dropped (see api.ts).
+//
+// Each convert tool returns BOTH a human-readable text summary AND an embedded
+// `application/pdf` resource (base64 blob) so capable MCP clients can save the file.
+// If FILETOPDF_OUTPUT_DIR is set (or a `save_path` is given) the PDF is also written
+// to disk — handy for local stdio use.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { convertFile, convertHtml, convertMarkdown, getAccount, FileToPdfError, } from "./api.js";
+// --- Shared option shapes (kept as strings to match the API's form handling) ---
+// Chromium render options — apply to HTML and Markdown. Available on Pro/Scale/trial.
+const chromiumOptions = {
+    landscape: z.boolean().optional().describe("Render in landscape orientation. (Pro/Scale/trial only.)"),
+    paperWidth: z.string().optional().describe('Paper width in inches, or with a unit e.g. "210mm".'),
+    paperHeight: z.string().optional().describe("Paper height in inches."),
+    marginTop: z.string().optional().describe("Top margin in inches."),
+    marginBottom: z.string().optional().describe("Bottom margin in inches."),
+    marginLeft: z.string().optional().describe("Left margin in inches."),
+    marginRight: z.string().optional().describe("Right margin in inches."),
+    scale: z.string().optional().describe("Render scale, 0.1–2.0."),
+    printBackground: z.boolean().optional().describe("Print background graphics/colors."),
+    preferCssPageSize: z.boolean().optional().describe("Use the page size declared in CSS @page rules."),
+    nativePageRanges: z.string().optional().describe('Page ranges to include, e.g. "1-3,5".'),
+    pdfa: z.string().optional().describe('PDF/A conformance level, e.g. "PDF/A-2b". (Pro/Scale/trial only.)'),
+    pdfua: z.boolean().optional().describe("Produce an accessible PDF/UA document."),
+    userPassword: z.string().optional().describe("Password required to open the resulting PDF."),
+    ownerPassword: z.string().optional().describe("Owner password controlling permissions on the resulting PDF."),
+    save_path: z.string().optional().describe("Optional absolute path to also write the PDF to on disk."),
+};
+// LibreOffice/document options — apply to convert_file (no paper size / margins / scale).
+const fileOptions = {
+    landscape: z.boolean().optional().describe("Render in landscape orientation. (Pro/Scale/trial only.)"),
+    nativePageRanges: z.string().optional().describe('Page ranges to include, e.g. "1-3".'),
+    password: z.string().optional().describe("Password to open a protected source document."),
+    pdfa: z.string().optional().describe('PDF/A conformance level, e.g. "PDF/A-2b". (Pro/Scale/trial only.)'),
+    pdfua: z.boolean().optional().describe("Produce an accessible PDF/UA document."),
+    userPassword: z.string().optional().describe("Password required to open the resulting PDF."),
+    ownerPassword: z.string().optional().describe("Owner password controlling permissions on the resulting PDF."),
+    save_path: z.string().optional().describe("Optional absolute path to also write the PDF to on disk."),
+};
+/** Build the standard tool result for a successful conversion. */
+async function pdfToolResult(result, savePath) {
+    let savedNote = "";
+    // Resolve a disk destination from the explicit save_path or FILETOPDF_OUTPUT_DIR.
+    let dest = savePath;
+    if (!dest && process.env.FILETOPDF_OUTPUT_DIR) {
+        dest = path.join(process.env.FILETOPDF_OUTPUT_DIR, result.filename);
+    }
+    if (dest) {
+        try {
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.writeFile(dest, Buffer.from(result.pdfBase64, "base64"));
+            savedNote = `\nSaved to: ${dest}`;
+        }
+        catch (e) {
+            savedNote = `\n(Could not write to "${dest}": ${e.message})`;
+        }
+    }
+    const summary = `✅ Converted to PDF.\n` +
+        `• File: ${result.filename}\n` +
+        `• Pages: ${result.pages ?? "?"}\n` +
+        `• Size: ${result.sizeBytes} bytes\n` +
+        `• Credits used: ${result.creditsUsed ?? "?"} (remaining: ${result.creditsRemaining ?? "?"})` +
+        savedNote;
+    return {
+        content: [
+            { type: "text", text: summary },
+            {
+                type: "resource",
+                resource: {
+                    uri: `filetopdf://output/${result.filename}`,
+                    mimeType: "application/pdf",
+                    blob: result.pdfBase64,
+                },
+            },
+        ],
+    };
+}
+/** Turn any thrown error into an MCP tool error result (never throws). */
+function errorResult(err) {
+    const message = err instanceof FileToPdfError
+        ? `FileToPDF error [${err.code}]: ${err.message}`
+        : `Unexpected error: ${err.message}`;
+    return { isError: true, content: [{ type: "text", text: message }] };
+}
+/** Split a validated args object into {known fields, leftover options}. */
+function takeOptions(args, drop) {
+    const opts = {};
+    for (const [k, v] of Object.entries(args)) {
+        if (!drop.includes(k))
+            opts[k] = v;
+    }
+    return opts;
+}
+/**
+ * Create a fully-configured FileToPDF MCP server. The transport supplies a resolver
+ * so each tool call reads the right API key (from env for stdio, from headers for HTTP).
+ */
+export function createServer(getApiKey) {
+    const server = new McpServer({
+        name: "filetopdf",
+        version: "0.1.0",
+    });
+    const requireKey = () => {
+        const key = getApiKey();
+        if (!key) {
+            throw new FileToPdfError("No FileToPDF API key. Set FILETOPDF_API_KEY (stdio) or send an x-api-key header (HTTP). Get a free key at https://filetopdf.dev.", { code: "missing_api_key", httpStatus: 401 });
+        }
+        return key;
+    };
+    server.registerTool("get_account", {
+        title: "Get FileToPDF account status",
+        description: "Check the FileToPDF API key and return the plan, remaining conversion credits, and subscription status. Free — costs no credits. Use this to verify the connection works.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async () => {
+        try {
+            const acct = await getAccount(requireKey());
+            const text = `FileToPDF · plan: ${acct.plan} · credits remaining: ${acct.credits_remaining} · ` +
+                `subscription: ${acct.subscription_status} · workspace: ${acct.workspace_id}`;
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    server.registerTool("convert_file", {
+        title: "Convert a file (by URL) to PDF",
+        description: "Convert a file fetched from a public URL into a PDF. Auto-detects the engine from the extension: Office docs (DOCX, XLSX, PPTX, ODT, RTF, TXT, CSV…), images (PNG, JPG, WebP…), HTML, Markdown, or an existing PDF (passthrough). Costs 1 credit on success. Returns the PDF as an embedded resource.",
+        inputSchema: {
+            url: z.string().url().describe("Public http(s) URL of the file to download and convert."),
+            ...fileOptions,
+        },
+        annotations: { openWorldHint: true },
+    }, async (args) => {
+        try {
+            const { url, save_path } = args;
+            const options = takeOptions(args, ["url", "save_path"]);
+            const result = await convertFile(requireKey(), url, options);
+            return await pdfToolResult(result, save_path);
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    server.registerTool("convert_html", {
+        title: "Convert HTML to PDF",
+        description: "Render a raw HTML string to a PDF using Chromium, with optional CSS and layout options. Costs 1 credit on success. Returns the PDF as an embedded resource.",
+        inputSchema: {
+            html: z.string().describe("The HTML markup to render."),
+            css: z.string().optional().describe("Optional CSS, injected into the document <head>."),
+            ...chromiumOptions,
+        },
+        annotations: { openWorldHint: true },
+    }, async (args) => {
+        try {
+            const { html, css, save_path } = args;
+            const options = takeOptions(args, ["html", "css", "save_path"]);
+            const result = await convertHtml(requireKey(), html, css, options);
+            return await pdfToolResult(result, save_path);
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    server.registerTool("convert_markdown", {
+        title: "Convert Markdown to PDF",
+        description: "Render a raw Markdown string to a PDF, with optional CSS and layout options. A sensible default stylesheet is applied when no CSS is given. Costs 1 credit on success. Returns the PDF as an embedded resource.",
+        inputSchema: {
+            markdown: z.string().describe("The Markdown content to render."),
+            css: z.string().optional().describe("Optional CSS to style the rendered Markdown (overrides the default stylesheet)."),
+            ...chromiumOptions,
+        },
+        annotations: { openWorldHint: true },
+    }, async (args) => {
+        try {
+            const { markdown, css, save_path } = args;
+            const options = takeOptions(args, ["markdown", "css", "save_path"]);
+            const result = await convertMarkdown(requireKey(), markdown, css, options);
+            return await pdfToolResult(result, save_path);
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+    return server;
+}

package/dist/stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/stdio.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// stdio entrypoint — the form most MCP clients (Claude Desktop, Cursor, Cline) and
+// directories (Glama, mcp.so) consume via `npx filetopdf-mcp`. The FileToPDF API key
+// comes from the FILETOPDF_API_KEY environment variable.
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer(() => process.env.FILETOPDF_API_KEY);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Never write to stdout — it's the protocol channel. Logs go to stderr.
+    console.error("filetopdf-mcp running on stdio");
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "filetopdf-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Model Context Protocol (MCP) server for FileToPDF — convert files, HTML, and Markdown to PDF from any MCP client (Claude, Cursor, etc.). Bring your own API key.",
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "filetopdf",
+    "pdf",
+    "html-to-pdf",
+    "markdown-to-pdf",
+    "document-conversion",
+    "claude",
+    "cursor"
+  ],
+  "homepage": "https://filetopdf.dev",
+  "license": "MIT",
+  "author": "FileToPDF <support@filetopdf.dev>",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "filetopdf-mcp": "dist/stdio.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/stdio.js",
+    "start:http": "node dist/http.js",
+    "prepare": "npm run build",
+    "test": "node test/live-test.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.4",
+    "@types/node": "^20.14.0"
+  }
+}