@mdtidy/mcp 1.0.0

package/dist/chunk-TABPKZQW.js

@@ -0,0 +1,1216 @@
+// ../../packages/client/src/errors.ts
+function isApiErrorBody(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const err = value.error;
+  return typeof err === "object" && err !== null && typeof err.code === "string";
+}
+var MdtidyApiError = class extends Error {
+  status;
+  code;
+  requestId;
+  details;
+  constructor(args) {
+    super(`mdtidy ${args.status} ${args.code}: ${args.message}`);
+    this.name = "MdtidyApiError";
+    this.status = args.status;
+    this.code = args.code;
+    this.requestId = args.requestId;
+    this.details = args.details;
+  }
+};
+
+// ../../node_modules/.pnpm/openapi-fetch@0.13.8/node_modules/openapi-fetch/dist/index.js
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const middlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      body,
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new CustomRequest(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (middlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch,
+        parseAs,
+        querySerializer,
+        bodySerializer
+      });
+      for (const m of middlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result2 = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result2) {
+            if (result2 instanceof CustomRequest) {
+              request = result2;
+            } else if (result2 instanceof Response) {
+              response = result2;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1; i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result2 = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result2) {
+                if (result2 instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result2;
+                  break;
+                }
+                if (result2 instanceof Error) {
+                  errorAfterMiddleware = result2;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (middlewares.length) {
+        for (let i = middlewares.length - 1; i >= 0; i--) {
+          const m = middlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result2 = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result2) {
+              if (!(result2 instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result2;
+            }
+          }
+        }
+      }
+    }
+    if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      if (parseAs === "stream") {
+        return { data: response.body, response };
+      }
+      return { data: await response[parseAs](), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        middlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = middlewares.indexOf(m);
+        if (i !== -1) {
+          middlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = defaultPathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// ../../packages/client/src/client.ts
+var DEFAULT_BASE_URL = "https://mdtidy.com";
+var DEFAULT_TIMEOUT_MS = 6e4;
+function withTimeout(baseFetch, timeoutMs) {
+  return (input2, init) => {
+    if (init?.signal) return baseFetch(input2, init);
+    return baseFetch(input2, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  };
+}
+function authMiddleware(apiKey) {
+  return {
+    onRequest({ request }) {
+      request.headers.set("X-API-KEY", apiKey);
+      request.headers.set("Authorization", `Bearer ${apiKey}`);
+      return request;
+    }
+  };
+}
+var throwOnError = {
+  async onResponse({ response }) {
+    if (response.ok) return response;
+    let body;
+    try {
+      body = await response.clone().json();
+    } catch {
+      body = void 0;
+    }
+    const err = isApiErrorBody(body) ? body.error : void 0;
+    throw new MdtidyApiError({
+      status: response.status,
+      code: err?.code ?? "http_error",
+      message: err?.message ?? (response.statusText || "request failed"),
+      requestId: err?.requestId,
+      details: err ? { required: err.required, balance: err.balance } : void 0
+    });
+  }
+};
+function createMdtidyClient(opts) {
+  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const baseFetch = opts.fetch ?? globalThis.fetch;
+  const client = createClient({ baseUrl, fetch: withTimeout(baseFetch, timeoutMs) });
+  client.use(authMiddleware(opts.apiKey), throwOnError);
+  return client;
+}
+
+// ../../packages/mcp-core/src/context.ts
+function buildContext(opts) {
+  return {
+    client: createMdtidyClient({
+      apiKey: opts.apiKey,
+      baseUrl: opts.baseUrl,
+      fetch: opts.fetch,
+      timeoutMs: opts.timeoutMs
+    }),
+    baseUrl: opts.baseUrl,
+    transport: opts.transport,
+    logger: opts.logger
+  };
+}
+
+// ../../packages/tools/src/catalog.ts
+var TOOL_CATALOG = [
+  {
+    name: "tidy_markdown",
+    group: "Convert",
+    operationId: "convert",
+    cost: 1,
+    title: "Tidy & convert Markdown",
+    description: "Clean and repair messy AI-generated Markdown and render it to HTML, plain text, PDF, DOCX, or PNG. Choose a design system (minimal-clean, executive-report, developer-docs) and optional page geometry. Costs 1 credit per successful render (auto-refunded on failure); returns the cleanup fixes applied and the remaining balance."
+  },
+  {
+    name: "check_usage",
+    group: "Read",
+    operationId: "usage",
+    cost: 0,
+    title: "Check credit usage",
+    description: "Return the caller's credit balance and recent API calls. Free \u2014 call it before a batch of conversions."
+  },
+  {
+    name: "get_entitlement",
+    group: "Read",
+    operationId: "credits",
+    cost: 0,
+    title: "Get plan entitlement",
+    description: "Return the caller's plan and workspace gates (can_save / can_share). Free."
+  },
+  {
+    name: "list_projects",
+    group: "Read",
+    operationId: "listProjects",
+    cost: 0,
+    title: "List projects",
+    description: "List the caller's projects. scope: mine | shared | archived (default mine). Free."
+  },
+  {
+    name: "get_project",
+    group: "Read",
+    operationId: "getProject",
+    cost: 0,
+    title: "Get a project",
+    description: "Return a project together with its folders and files. Free."
+  },
+  {
+    name: "get_file",
+    group: "Read",
+    operationId: "getFile",
+    cost: 0,
+    title: "Read a file",
+    description: "Return a saved file's Markdown content plus its version/ETag. Free."
+  },
+  {
+    name: "create_project",
+    group: "Write",
+    operationId: "createProject",
+    cost: 0,
+    title: "Create a project",
+    description: "Create a workspace project (a container for files). Free."
+  },
+  {
+    name: "save_document",
+    group: "Write",
+    operationId: ["listProjects", "createProject", "getProject", "createFile", "updateFile"],
+    cost: "1/0",
+    title: "Save a document (upsert)",
+    description: 'Fast path \u2014 save Markdown in one step. Finds or creates the target project (default "Drafts") and creates the file, or updates it if a same-named document already exists. 1 credit on create, 0 on update. Returns the file id, project, and a link. Use this to start fast; use the granular tools for structured workspaces.'
+  },
+  {
+    name: "save_file",
+    group: "Write",
+    operationId: "createFile",
+    cost: 1,
+    title: "Create a file",
+    description: "First-save a Markdown file into a known project (idempotent via an idempotency key). 1 credit."
+  },
+  {
+    name: "update_file",
+    group: "Write",
+    operationId: "updateFile",
+    cost: 0,
+    title: "Update a file",
+    description: "Autosave, rename, or move a file. Content writes use If-Match for safe concurrent edits. Free."
+  },
+  {
+    name: "get_project_share",
+    group: "Share",
+    operationId: "getProjectShare",
+    cost: 0,
+    title: "Get share state",
+    description: "Return a project's current share state and public URL. Free."
+  },
+  {
+    name: "share_project_public",
+    group: "Share",
+    operationId: "enableProjectPublicLink",
+    cost: 1,
+    title: "Share a project publicly",
+    description: "Turn on a project's public link and return https://mdtidy.com/p/{slug}. 1 credit (free within the 30-day slug grace)."
+  }
+];
+function catalogMeta(name) {
+  const entry = TOOL_CATALOG.find((t) => t.name === name);
+  if (!entry) throw new Error(`No catalog entry for tool "${name}"`);
+  return { name: entry.name, title: entry.title, description: entry.description, cost: entry.cost };
+}
+var DEFERRED_TOOLS = [
+  { name: "update_project", operationId: "updateProject" },
+  { name: "delete_project", operationId: "deleteProject" },
+  { name: "delete_file", operationId: "deleteFile" },
+  { name: "copy_file", operationId: "copyFile" },
+  { name: "create_folder", operationId: "createFolder" },
+  { name: "update_folder", operationId: "updateFolder" },
+  { name: "delete_folder", operationId: "deleteFolder" },
+  { name: "regenerate_public_link", operationId: "regenerateProjectPublicLink" },
+  { name: "invite_viewers", operationId: "inviteProjectViewers" },
+  { name: "remove_invitee", operationId: "removeProjectInvitee" },
+  { name: "make_project_private", operationId: "makeProjectPrivate" },
+  { name: "disable_public_link", operationId: "disableProjectPublicLink" }
+];
+
+// ../../packages/tools/src/tools/read.ts
+import { z } from "zod";
+
+// ../../packages/tools/src/shape.ts
+function jsonText(value) {
+  return { type: "text", text: JSON.stringify(value, null, 2) };
+}
+function text(value) {
+  return { type: "text", text: value };
+}
+function result(...content) {
+  return { content };
+}
+async function shapeConvertResult(data, input2, ctx) {
+  const fixes = data.warnings.length > 0 ? data.warnings.map((w) => `${w.rule}\xD7${w.fixes}`).join(", ") : "no changes needed";
+  const summary = `Tidied \u2192 ${data.format} (${data.byteSize} bytes, design system "${data.designSystem}"). Fixes: ${fixes}. Credits charged ${data.creditsCharged}, remaining ${data.creditsRemaining}.`;
+  const blocks = [];
+  if (data.format === "html" || data.format === "text") {
+    blocks.push(text(data.output ?? ""));
+  } else if (data.format === "png") {
+    if (data.outputBase64)
+      blocks.push({ type: "image", data: data.outputBase64, mimeType: "image/png" });
+  } else {
+    if (ctx.transport === "stdio" && input2.savePath && data.outputBase64) {
+      const { writeFileSync } = await import("fs");
+      writeFileSync(input2.savePath, Buffer.from(data.outputBase64, "base64"));
+      blocks.push(text(`Saved ${data.format.toUpperCase()} to ${input2.savePath}`));
+    } else if (data.outputBase64) {
+      blocks.push({
+        type: "resource",
+        resource: {
+          uri: `mdtidy://convert/${data.requestId}.${data.format}`,
+          mimeType: data.contentType,
+          blob: data.outputBase64
+        }
+      });
+    }
+  }
+  blocks.push(text(summary));
+  return { content: blocks };
+}
+
+// ../../packages/tools/src/types.ts
+function defineTool(def) {
+  return def;
+}
+
+// ../../packages/tools/src/tools/read.ts
+var checkUsage = defineTool({
+  ...catalogMeta("check_usage"),
+  inputSchema: z.object({}),
+  handler: async (_i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/usage", {});
+    const u = data;
+    return result(
+      text(
+        `Credits remaining: ${u.creditsRemaining} (subscription ${u.subscriptionCredits} + top-up ${u.topupCredits}). Calls this period: ${u.callsThisPeriod}.`
+      ),
+      jsonText(u)
+    );
+  }
+});
+var getEntitlement = defineTool({
+  ...catalogMeta("get_entitlement"),
+  inputSchema: z.object({}),
+  handler: async (_i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/credits", {});
+    const e = data;
+    return result(
+      text(
+        `Plan: ${e.plan}. Balance: ${e.credits_balance}. can_save=${e.can_save} can_share=${e.can_share}.`
+      ),
+      jsonText(e)
+    );
+  }
+});
+var listProjects = defineTool({
+  ...catalogMeta("list_projects"),
+  inputSchema: z.object({
+    scope: z.enum(["mine", "shared", "archived"]).optional().describe("Which projects to list. Defaults to mine.")
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/projects", {
+      params: { query: i.scope ? { scope: i.scope } : {} }
+    });
+    const d = data;
+    return result(text(`${d.items.length} project(s) in scope "${d.scope}".`), jsonText(d.items));
+  }
+});
+var getProject = defineTool({
+  ...catalogMeta("get_project"),
+  inputSchema: z.object({
+    id: z.string().uuid().describe("Project id."),
+    includeArchived: z.boolean().optional().describe("Include archived files. Default false.")
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/projects/{id}", {
+      params: {
+        path: { id: i.id },
+        query: i.includeArchived != null ? { include_archived: i.includeArchived } : {}
+      }
+    });
+    return result(jsonText(data));
+  }
+});
+var getFile = defineTool({
+  ...catalogMeta("get_file"),
+  inputSchema: z.object({ id: z.string().uuid().describe("File id.") }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/files/{id}", {
+      params: { path: { id: i.id } }
+    });
+    const f = data;
+    return result(text(`File "${f.name}" (v${f.version}). ETag ${f.etag}.`), text(f.content ?? ""));
+  }
+});
+
+// ../../packages/tools/src/tools/share.ts
+import { z as z2 } from "zod";
+var getProjectShare = defineTool({
+  ...catalogMeta("get_project_share"),
+  inputSchema: z2.object({ id: z2.string().uuid().describe("Project id.") }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.GET("/api/v1/projects/{id}/share", {
+      params: { path: { id: i.id } }
+    });
+    return result(jsonText(data));
+  }
+});
+var shareProjectPublic = defineTool({
+  ...catalogMeta("share_project_public"),
+  inputSchema: z2.object({
+    id: z2.string().uuid().describe("Project id."),
+    idempotencyKey: z2.string().optional()
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.POST("/api/v1/projects/{id}/share/public", {
+      params: {
+        path: { id: i.id },
+        ...i.idempotencyKey ? { header: { "Idempotency-Key": i.idempotencyKey } } : {}
+      }
+    });
+    const s = data;
+    return result(
+      text(`Public link: ${s.public_url ?? s.project_url ?? "(enabled)"}`),
+      jsonText(s)
+    );
+  }
+});
+
+// ../../packages/tools/src/tools/tidy-markdown.ts
+import { z as z3 } from "zod";
+var input = z3.object({
+  markdown: z3.string().min(1).describe("The Markdown to clean and convert."),
+  format: z3.enum(["html", "text", "pdf", "docx", "png"]).describe("Output format. html/text return inline; pdf/docx/png return a file or resource."),
+  designSystem: z3.enum(["minimal-clean", "executive-report", "developer-docs"]).optional().describe("Visual theme. Defaults to minimal-clean."),
+  page: z3.object({
+    paperSize: z3.enum(["Letter", "A4", "A3"]).optional(),
+    orientation: z3.enum(["portrait", "landscape"]).optional(),
+    marginPreset: z3.enum(["narrow", "normal", "wide"]).optional(),
+    fontScale: z3.enum(["down", "normal", "up"]).optional()
+  }).optional().describe("Optional page geometry + font scale (render-only; no credit cost)."),
+  tidy: z3.object({
+    enable: z3.boolean().optional(),
+    polish: z3.boolean().optional()
+  }).optional().describe("Tidy pipeline toggles. Both default to true."),
+  savePath: z3.string().optional().describe("(stdio only) write binary output (pdf/docx/png) to this local path and return it.")
+});
+var tidyMarkdown = defineTool({
+  ...catalogMeta("tidy_markdown"),
+  inputSchema: input,
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.POST("/api/v1/convert", {
+      body: {
+        markdown: i.markdown,
+        format: i.format,
+        ...i.designSystem ? { designSystem: i.designSystem } : {},
+        ...i.page ? { page: i.page } : {},
+        ...i.tidy ? { settings: { tidy: i.tidy } } : {}
+      }
+    });
+    return shapeConvertResult(data, i, ctx);
+  }
+});
+
+// ../../packages/tools/src/tools/write.ts
+import { z as z4 } from "zod";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function deriveName(markdown) {
+  const heading = markdown.match(/^#\s+(.+?)\s*$/m);
+  return (heading?.[1] ?? "Untitled").slice(0, 200);
+}
+async function resolveProject(ctx, project) {
+  const wanted = project?.trim() || "Drafts";
+  if (UUID_RE.test(wanted)) {
+    const { data } = await ctx.client.GET("/api/v1/projects/{id}", {
+      params: { path: { id: wanted }, query: {} }
+    });
+    return { id: data.id, name: data.name };
+  }
+  const findByName = async () => {
+    const { data } = await ctx.client.GET("/api/v1/projects", {
+      params: { query: { scope: "mine" } }
+    });
+    const found = data.items.find((p) => p.name === wanted);
+    return found ? { id: found.id, name: found.name } : void 0;
+  };
+  const existing = await findByName();
+  if (existing) return existing;
+  try {
+    const { data } = await ctx.client.POST("/api/v1/projects", { body: { name: wanted } });
+    return { id: data.id, name: data.name };
+  } catch (err) {
+    if (err instanceof MdtidyApiError && err.status === 409) {
+      const afterRace = await findByName();
+      if (afterRace) return afterRace;
+    }
+    throw err;
+  }
+}
+async function patchContent(ctx, fileId, etag, content) {
+  const { data } = await ctx.client.PATCH("/api/v1/files/{id}", {
+    params: { path: { id: fileId }, header: { "If-Match": etag } },
+    body: { content }
+  });
+  return data;
+}
+var createProject = defineTool({
+  ...catalogMeta("create_project"),
+  inputSchema: z4.object({
+    name: z4.string().min(1).max(200).describe("Project name."),
+    description: z4.string().max(2e3).optional()
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.POST("/api/v1/projects", {
+      body: { name: i.name, ...i.description ? { description: i.description } : {} }
+    });
+    return result(text(`Created project "${data.name}" (${data.id}).`), jsonText(data));
+  }
+});
+var saveFile = defineTool({
+  ...catalogMeta("save_file"),
+  inputSchema: z4.object({
+    project_id: z4.string().uuid().describe("Target project id."),
+    name: z4.string().min(1).max(200),
+    content: z4.string().describe("Markdown body."),
+    folder_id: z4.string().uuid().optional(),
+    idempotencyKey: z4.string().optional()
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.POST("/api/v1/files", {
+      ...i.idempotencyKey ? { params: { header: { "Idempotency-Key": i.idempotencyKey } } } : {},
+      body: {
+        project_id: i.project_id,
+        name: i.name,
+        content: i.content,
+        ...i.folder_id ? { folder_id: i.folder_id } : {}
+      }
+    });
+    return result(
+      text(`Saved file "${data.name}" (${data.id}). 1 credit charged.`),
+      jsonText(data)
+    );
+  }
+});
+var updateFile = defineTool({
+  ...catalogMeta("update_file"),
+  inputSchema: z4.object({
+    id: z4.string().uuid(),
+    content: z4.string().optional(),
+    name: z4.string().min(1).max(200).optional(),
+    folder_id: z4.string().uuid().nullable().optional(),
+    archived: z4.boolean().optional(),
+    ifMatch: z4.string().optional().describe("ETag/version for safe content writes (required when changing content).")
+  }),
+  handler: async (i, ctx) => {
+    const { data } = await ctx.client.PATCH("/api/v1/files/{id}", {
+      params: {
+        path: { id: i.id },
+        ...i.ifMatch ? { header: { "If-Match": i.ifMatch } } : {}
+      },
+      body: {
+        ...i.content != null ? { content: i.content } : {},
+        ...i.name != null ? { name: i.name } : {},
+        ...i.folder_id !== void 0 ? { folder_id: i.folder_id } : {},
+        ...i.archived != null ? { archived: i.archived } : {}
+      }
+    });
+    return result(text(`Updated file "${data.name}" (v${data.version}).`), jsonText(data));
+  }
+});
+var saveDocument = defineTool({
+  ...catalogMeta("save_document"),
+  inputSchema: z4.object({
+    content: z4.string().min(1).describe("Markdown body to save."),
+    name: z4.string().max(200).optional().describe('Document name. Defaults to the first H1, else "Untitled".'),
+    project: z4.string().optional().describe('Project id, or a name to find-or-create. Defaults to "Drafts".'),
+    idempotencyKey: z4.string().optional()
+  }),
+  handler: async (i, ctx) => {
+    const name = i.name?.trim() || deriveName(i.content);
+    const project = await resolveProject(ctx, i.project);
+    const { data: full } = await ctx.client.GET("/api/v1/projects/{id}", {
+      params: { path: { id: project.id }, query: {} }
+    });
+    const files = full.files ?? [];
+    const existing = files.find((f) => f.name === name && !f.archived);
+    let file;
+    let created;
+    if (existing) {
+      try {
+        file = await patchContent(ctx, existing.id, existing.etag, i.content);
+      } catch (err) {
+        if (err instanceof MdtidyApiError && err.status === 409) {
+          const { data: fresh } = await ctx.client.GET("/api/v1/projects/{id}", {
+            params: { path: { id: project.id }, query: {} }
+          });
+          const again = (fresh.files ?? []).find(
+            (f) => f.name === name && !f.archived
+          );
+          if (!again) throw err;
+          file = await patchContent(ctx, again.id, again.etag, i.content);
+        } else {
+          throw err;
+        }
+      }
+      created = false;
+    } else {
+      const { data } = await ctx.client.POST("/api/v1/files", {
+        ...i.idempotencyKey ? { params: { header: { "Idempotency-Key": i.idempotencyKey } } } : {},
+        body: { project_id: project.id, name, content: i.content }
+      });
+      file = data;
+      created = true;
+    }
+    const url = `${ctx.baseUrl}/edit/${file.id}`;
+    const summary = created ? `Created "${name}" in project "${project.name}". 1 credit charged.` : `Updated "${name}" in project "${project.name}". No credit (update).`;
+    return result(
+      text(summary),
+      jsonText({
+        file_id: file.id,
+        name,
+        project,
+        version: file.version,
+        etag: file.etag,
+        url,
+        created,
+        creditsRemaining: file.credits_remaining ?? null
+      })
+    );
+  }
+});
+
+// ../../packages/tools/src/registry.ts
+var REGISTRY = [
+  tidyMarkdown,
+  checkUsage,
+  getEntitlement,
+  listProjects,
+  getProject,
+  getFile,
+  createProject,
+  saveDocument,
+  saveFile,
+  updateFile,
+  getProjectShare,
+  shareProjectPublic
+];
+
+// ../../packages/mcp-core/src/register.ts
+function registerTools(server, ctx, tools = REGISTRY) {
+  for (const tool of tools) {
+    server.registerTool(
+      tool.name,
+      {
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema.shape
+      },
+      async (args) => {
+        const res = await tool.handler(args, ctx);
+        return { content: res.content, isError: res.isError };
+      }
+    );
+  }
+}
+
+// ../../packages/mcp-core/src/server-info.ts
+var SERVER_INFO = {
+  name: "mdtidy",
+  version: "1.0.0",
+  title: "Markdown Tidy"
+};
+var PROTOCOL_VERSION = "2025-06-18";
+
+// ../../packages/mcp-core/src/jsonrpc.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+function toolInputJsonSchema(tool) {
+  const schema = zodToJsonSchema(tool.inputSchema, {
+    target: "jsonSchema7",
+    $refStrategy: "none"
+  });
+  delete schema.$schema;
+  return schema;
+}
+async function handleJsonRpc(req, ctx, opts = {}) {
+  const tools = opts.tools ?? REGISTRY;
+  const id = req.id ?? null;
+  const ok = (result2) => ({ jsonrpc: "2.0", id, result: result2 });
+  const fail = (code, message) => ({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message }
+  });
+  switch (req.method) {
+    case "initialize": {
+      const requested = req.params?.protocolVersion;
+      return ok({
+        protocolVersion: typeof requested === "string" ? requested : PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: SERVER_INFO
+      });
+    }
+    case "ping":
+      return ok({});
+    case "tools/list":
+      return ok({
+        tools: tools.map((t) => ({
+          name: t.name,
+          title: t.title,
+          description: t.description,
+          inputSchema: toolInputJsonSchema(t)
+        }))
+      });
+    case "tools/call": {
+      const name = req.params?.name;
+      const tool = tools.find((t) => t.name === name);
+      if (!tool) return fail(-32602, `Unknown tool: ${name}`);
+      const parsed = tool.inputSchema.safeParse(req.params?.arguments ?? {});
+      if (!parsed.success) {
+        const detail = parsed.error.issues.map((iss) => `${iss.path.join(".")}: ${iss.message}`).join("; ");
+        return fail(-32602, `Invalid arguments for ${name}: ${detail}`);
+      }
+      try {
+        const res = await tool.handler(parsed.data, ctx);
+        return ok({ content: res.content, isError: res.isError ?? false });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return ok({ content: [{ type: "text", text: `Error: ${message}` }], isError: true });
+      }
+    }
+    default:
+      if (req.id === void 0 || req.method.startsWith("notifications/")) return null;
+      return fail(-32601, `Method not found: ${req.method}`);
+  }
+}
+
+// ../../packages/mcp-core/src/stdio.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startStdio(opts = {}) {
+  const apiKey = opts.apiKey ?? process.env.MDTIDY_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "MDTIDY_API_KEY is required. Create a key at https://mdtidy.com/account/api-keys and set it in your MCP client config."
+    );
+  }
+  const baseUrl = opts.baseUrl ?? process.env.MDTIDY_BASE_URL ?? "https://mdtidy.com";
+  const ctx = buildContext({ apiKey, baseUrl, transport: "stdio" });
+  const server = new McpServer(
+    { name: SERVER_INFO.name, version: SERVER_INFO.version },
+    { capabilities: { tools: {} } }
+  );
+  registerTools(server, ctx);
+  await server.connect(new StdioServerTransport());
+}
+
+// ../../packages/mcp-core/src/http.ts
+function json(body, status) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function extractApiKey(req) {
+  const auth = req.headers.get("authorization");
+  if (auth && auth.toLowerCase().startsWith("bearer ")) return auth.slice(7).trim();
+  const xKey = req.headers.get("x-api-key");
+  return xKey?.trim() || void 0;
+}
+function createMcpRouteHandler(options = {}) {
+  return async function handler(req) {
+    if (req.method === "GET" || req.method === "DELETE") {
+      return json(
+        {
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32e3, message: "This MCP server is stateless; use POST." }
+        },
+        405
+      );
+    }
+    if (req.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+    const apiKey = extractApiKey(req);
+    if (!apiKey) {
+      return json(
+        {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32001,
+            message: 'Missing API key. Send "Authorization: Bearer <mdtidy key>" or "X-API-KEY". Create one at https://mdtidy.com/account/api-keys.'
+          }
+        },
+        401
+      );
+    }
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return json(
+        { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } },
+        400
+      );
+    }
+    const baseUrl = options.resolveBaseUrl?.(req) ?? options.defaultBaseUrl ?? "https://mdtidy.com";
+    const ctx = buildContext({ apiKey, baseUrl, transport: "http", fetch: options.fetch });
+    if (Array.isArray(body)) {
+      const responses = (await Promise.all(body.map((m) => handleJsonRpc(m, ctx)))).filter((r) => r !== null);
+      return json(responses, 200);
+    }
+    const res = await handleJsonRpc(body, ctx);
+    if (res === null) return new Response(null, { status: 202 });
+    return json(res, 200);
+  };
+}
+
+export {
+  MdtidyApiError,
+  createMdtidyClient,
+  buildContext,
+  TOOL_CATALOG,
+  DEFERRED_TOOLS,
+  REGISTRY,
+  registerTools,
+  SERVER_INFO,
+  PROTOCOL_VERSION,
+  handleJsonRpc,
+  startStdio,
+  createMcpRouteHandler
+};
+//# sourceMappingURL=chunk-TABPKZQW.js.map