notion-mcp-server 1.0.0 → 2.4.2

package/build/utils/schema-slice.js

@@ -0,0 +1,156 @@
+// Slice a JSON Schema down to the failing field at a given path, and
+// summarize any unions / deep nesting so the error envelope stays small.
+//
+// The full schema is always available via `notion_describe`; in a validation
+// error we only need to show the LLM what the failing field expects, plus a
+// working example. The unsliced schemas can be 10+KB (set_page_property's
+// value union, update_database's properties propertyNames union, etc.).
+const DEFAULT_SUMMARY_DEPTH = 2;
+function resolveRef(node, defs) {
+    const ref = node["$ref"];
+    if (typeof ref !== "string" || !defs)
+        return node;
+    const match = /^#\/\$defs\/(.+)$/.exec(ref);
+    if (!match)
+        return node;
+    if (!Object.hasOwn(defs, match[1]))
+        return node;
+    const resolved = defs[match[1]];
+    if (typeof resolved !== "object" || resolved === null)
+        return node;
+    return resolved;
+}
+function asObject(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    return value;
+}
+export function sliceJsonSchema(root, path) {
+    const defs = root.$defs;
+    let cur = root;
+    for (const seg of path) {
+        cur = resolveRef(cur, defs);
+        if (typeof seg === "string") {
+            // Only follow own-property keys: a Zod error path comes from caller-supplied
+            // payload field names, so `__proto__` / `constructor` could otherwise walk
+            // the prototype chain when slicing.
+            const props = asObject(cur.properties);
+            if (props && Object.hasOwn(props, seg)) {
+                const next = asObject(props[seg]);
+                if (next) {
+                    cur = next;
+                    continue;
+                }
+            }
+            const branches = (cur.oneOf ?? cur.anyOf);
+            if (Array.isArray(branches)) {
+                const matched = branches
+                    .map((b) => resolveRef(b, defs))
+                    .find((b) => {
+                    const p = asObject(b.properties);
+                    return p !== undefined && Object.hasOwn(p, seg);
+                });
+                if (matched) {
+                    const props = asObject(matched.properties);
+                    if (props) {
+                        const next = asObject(props[seg]);
+                        if (next) {
+                            cur = next;
+                            continue;
+                        }
+                    }
+                }
+            }
+            return cur;
+        }
+        if (typeof seg === "number") {
+            const items = cur.items;
+            if (Array.isArray(items)) {
+                const next = asObject(items[seg]);
+                if (next) {
+                    cur = next;
+                    continue;
+                }
+            }
+            else if (items) {
+                const next = asObject(items);
+                if (next) {
+                    cur = next;
+                    continue;
+                }
+            }
+            return cur;
+        }
+    }
+    return resolveRef(cur, defs);
+}
+// Replace large unions with a one-line-per-branch discriminator summary,
+// and cap nested objects/arrays at DEFAULT_SUMMARY_DEPTH.
+export function summarizeSchema(schema, depth = DEFAULT_SUMMARY_DEPTH, defs) {
+    const allDefs = defs ?? schema.$defs;
+    const resolved = resolveRef(schema, allDefs);
+    if (depth < 0) {
+        const t = resolved.type;
+        return { _truncated: true, ...(t ? { type: t } : {}) };
+    }
+    for (const key of ["oneOf", "anyOf"]) {
+        const branches = resolved[key];
+        if (Array.isArray(branches)) {
+            const summary = branches.map((b) => discriminatorSummary(b, allDefs));
+            const out = { [key]: summary };
+            if (resolved.description)
+                out.description = resolved.description;
+            return out;
+        }
+    }
+    if (resolved.type === "object" && asObject(resolved.properties)) {
+        const props = resolved.properties;
+        const summarizedProps = {};
+        for (const [k, v] of Object.entries(props)) {
+            summarizedProps[k] = summarizeSchema(v, depth - 1, allDefs);
+        }
+        const out = { ...resolved, properties: summarizedProps };
+        delete out.$defs;
+        return out;
+    }
+    if (resolved.type === "array") {
+        const items = resolved.items;
+        if (items && !Array.isArray(items)) {
+            const out = {
+                ...resolved,
+                items: summarizeSchema(items, depth - 1, allDefs),
+            };
+            delete out.$defs;
+            return out;
+        }
+    }
+    const out = { ...resolved };
+    delete out.$defs;
+    return out;
+}
+// One-line-per-branch: if a branch has a property with a literal `const`
+// (Zod literals emit as such), surface it as the discriminator tag. Otherwise
+// fall back to `type` + the first required field name.
+function discriminatorSummary(branch, defs) {
+    const resolved = resolveRef(branch, defs);
+    const props = asObject(resolved.properties);
+    if (props) {
+        for (const [k, v] of Object.entries(props)) {
+            const val = asObject(v);
+            if (val && val.const !== undefined) {
+                return { [k]: val.const };
+            }
+        }
+        const required = resolved.required;
+        if (Array.isArray(required) && required.length > 0) {
+            return { type: "object", required };
+        }
+    }
+    if (resolved.type)
+        return { type: resolved.type };
+    if (resolved.const !== undefined)
+        return { const: resolved.const };
+    if (Array.isArray(resolved.enum))
+        return { enum: resolved.enum };
+    return resolved;
+}

package/build/utils/slim.js

@@ -0,0 +1,269 @@
+import { isFullBlock, isFullComment, isFullDatabase, isFullDataSource, isFullPage, isFullUser, } from "@notionhq/client";
+function extractRichText(rich) {
+    return rich.map((r) => r.plain_text).join("");
+}
+function extractTitle(properties) {
+    for (const value of Object.values(properties)) {
+        if (value.type === "title")
+            return extractRichText(value.title);
+    }
+    return undefined;
+}
+// Flatten a single Notion property to a primitive (or small object) the LLM
+// can read directly. Returns undefined for empty values so the caller can skip
+// them — keeps the response tight for sparsely populated rows.
+function flattenProperty(prop) {
+    switch (prop.type) {
+        case "title":
+            return extractRichText(prop.title) || undefined;
+        case "rich_text":
+            return extractRichText(prop.rich_text) || undefined;
+        case "number":
+            return prop.number ?? undefined;
+        case "select":
+            return prop.select?.name ?? undefined;
+        case "multi_select":
+            return prop.multi_select.length ? prop.multi_select.map((s) => s.name) : undefined;
+        case "status":
+            return prop.status?.name ?? undefined;
+        case "date": {
+            if (!prop.date)
+                return undefined;
+            const { start, end } = prop.date;
+            return end ? { start, end } : start;
+        }
+        case "people":
+            return prop.people.length ? prop.people.map((p) => p.id) : undefined;
+        case "files":
+            return prop.files.length
+                ? prop.files.map((f) => {
+                    if (f.type === "external")
+                        return { name: f.name, url: f.external.url };
+                    return { name: f.name, url: f.file.url };
+                })
+                : undefined;
+        case "checkbox":
+            return prop.checkbox;
+        case "url":
+            return prop.url ?? undefined;
+        case "email":
+            return prop.email ?? undefined;
+        case "phone_number":
+            return prop.phone_number ?? undefined;
+        case "formula": {
+            const f = prop.formula;
+            if (f.type === "string")
+                return f.string ?? undefined;
+            if (f.type === "number")
+                return f.number ?? undefined;
+            if (f.type === "boolean")
+                return f.boolean ?? undefined;
+            if (f.type === "date")
+                return f.date?.start ?? undefined;
+            return undefined;
+        }
+        case "relation":
+            return prop.relation.length ? prop.relation.map((r) => r.id) : undefined;
+        case "rollup": {
+            const r = prop.rollup;
+            if (r.type === "number")
+                return r.number ?? undefined;
+            if (r.type === "date")
+                return r.date?.start ?? undefined;
+            if (r.type === "array") {
+                if (!r.array.length)
+                    return undefined;
+                const flat = r.array
+                    .map((item) => flattenProperty(item))
+                    .filter((v) => v !== undefined);
+                return flat.length ? flat : undefined;
+            }
+            return undefined;
+        }
+        case "created_time":
+            return prop.created_time;
+        case "last_edited_time":
+            return prop.last_edited_time;
+        case "created_by":
+            return prop.created_by.id;
+        case "last_edited_by":
+            return prop.last_edited_by.id;
+        case "unique_id": {
+            const { prefix, number } = prop.unique_id;
+            if (number == null)
+                return undefined;
+            return prefix ? `${prefix}-${number}` : number;
+        }
+        case "verification":
+            return prop.verification?.state ?? undefined;
+        default:
+            return undefined;
+    }
+}
+function flattenProperties(properties) {
+    const out = {};
+    for (const [name, value] of Object.entries(properties)) {
+        // Skip the title prop — already surfaced as `title`.
+        if (value.type === "title")
+            continue;
+        const flat = flattenProperty(value);
+        if (flat !== undefined)
+            out[name] = flat;
+    }
+    return out;
+}
+export function slimPage(page, verbose = false, includeProperties = false) {
+    if (verbose)
+        return page;
+    if (!isFullPage(page))
+        return { id: page.id };
+    const base = {
+        id: page.id,
+        url: page.url,
+        title: extractTitle(page.properties),
+        parent: page.parent,
+        ...(page.in_trash ? { in_trash: true } : {}),
+        ...(page.icon ? { icon: page.icon.type } : {}),
+    };
+    if (!includeProperties)
+        return base;
+    const props = flattenProperties(page.properties);
+    return Object.keys(props).length ? { ...base, properties: props } : base;
+}
+export function slimBlock(block, verbose = false) {
+    if (verbose)
+        return block;
+    if (!isFullBlock(block))
+        return { id: block.id };
+    const base = {
+        id: block.id,
+        type: block.type,
+        text: extractBlockText(block),
+        ...(block.has_children ? { has_children: true } : {}),
+        ...(block.in_trash ? { in_trash: true } : {}),
+    };
+    if (block.type === "to_do") {
+        return { ...base, checked: block.to_do.checked };
+    }
+    if (block.type === "code") {
+        return { ...base, language: block.code.language };
+    }
+    if (block.type === "image") {
+        const img = block.image;
+        const url = img.type === "external" ? img.external.url : img.file.url;
+        return { ...base, image: url };
+    }
+    return base;
+}
+function extractBlockText(block) {
+    // Many block subtypes expose a `rich_text` array under their type key.
+    // Read it via a structural narrow so we don't have to enumerate every variant.
+    const inner = block[block.type];
+    if (typeof inner !== "object" || inner === null)
+        return undefined;
+    const richText = inner.rich_text;
+    if (!Array.isArray(richText))
+        return undefined;
+    return extractRichText(richText);
+}
+export function slimDatabase(db, verbose = false) {
+    if (verbose)
+        return db;
+    if (!isFullDatabase(db))
+        return { id: db.id };
+    const description = extractRichText(db.description);
+    return {
+        id: db.id,
+        url: db.url,
+        title: extractRichText(db.title),
+        ...(description ? { description } : {}),
+        parent: db.parent,
+        ...(db.in_trash ? { in_trash: true } : {}),
+        ...(db.is_inline ? { is_inline: true } : {}),
+        ...(db.is_locked ? { is_locked: true } : {}),
+        data_sources: db.data_sources.map((s) => ({ id: s.id, name: s.name })),
+        ...(db.icon ? { icon: db.icon.type } : {}),
+    };
+}
+export function slimDataSource(ds, verbose = false) {
+    if (verbose)
+        return ds;
+    if (!isFullDataSource(ds))
+        return { id: ds.id };
+    const description = extractRichText(ds.description);
+    return {
+        id: ds.id,
+        url: ds.url,
+        title: extractRichText(ds.title),
+        ...(description ? { description } : {}),
+        parent: ds.parent,
+        // name → property-type map. Same byte cost as a name-only array but the
+        // type info is what query_database planners actually need (otherwise
+        // callers would have to drop verbose:true just to learn types).
+        properties: Object.fromEntries(Object.entries(ds.properties).map(([name, def]) => [name, def.type])),
+        ...(ds.icon ? { icon: ds.icon.type } : {}),
+        ...(ds.in_trash ? { in_trash: true } : {}),
+    };
+}
+export function slimItem(item, verbose = false, includeProperties = false) {
+    if (verbose)
+        return item;
+    if (item.object === "page")
+        return slimPage(item, verbose, includeProperties);
+    if (item.object === "database")
+        return slimDatabase(item, verbose);
+    return slimDataSource(item, verbose);
+}
+export function slimUser(user, verbose = false) {
+    if (verbose)
+        return user;
+    if (!isFullUser(user))
+        return { id: user.id };
+    const base = {
+        id: user.id,
+        type: user.type,
+        name: user.name,
+        ...(user.avatar_url ? { avatar_url: user.avatar_url } : {}),
+    };
+    if (user.type === "person")
+        return { ...base, email: user.person.email };
+    if (user.type === "bot") {
+        const workspaceName = "workspace_name" in user.bot ? user.bot.workspace_name : undefined;
+        return workspaceName ? { ...base, workspace_name: workspaceName } : base;
+    }
+    return base;
+}
+export function slimFileUpload(fu, verbose = false) {
+    if (verbose)
+        return fu;
+    return {
+        file_upload_id: fu.id,
+        ...(fu.status ? { status: fu.status } : {}),
+        ...(fu.filename ? { filename: fu.filename } : {}),
+        ...(fu.content_type ? { content_type: fu.content_type } : {}),
+        ...(fu.content_length !== undefined && fu.content_length !== null
+            ? { content_length: fu.content_length }
+            : {}),
+        ...(fu.expiry_time ? { expiry_time: fu.expiry_time } : {}),
+    };
+}
+export function slimComment(comment, verbose = false) {
+    if (verbose)
+        return comment;
+    if (!isFullComment(comment))
+        return { id: comment.id };
+    return {
+        id: comment.id,
+        parent: comment.parent,
+        discussion_id: comment.discussion_id,
+        text: extractRichText(comment.rich_text),
+        created_by: comment.created_by.id,
+    };
+}
+export function slimList(list, slim, verbose = false) {
+    return {
+        results: list.results.map((r) => slim(r, verbose)),
+        has_more: list.has_more ?? false,
+        next_cursor: list.next_cursor ?? null,
+    };
+}

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "notion-mcp-server",
-  "version": "1.0.0",
+  "version": "2.4.2",
   "type": "module",
   "bin": {
     "notion-mcp-server": "build/index.js"
   },
   "scripts": {
-    "build": "tsc && shx chmod +x build/*.js",
+    "build": "shx rm -rf build && tsc && shx chmod +x build/*.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js -e NOTION_TOKEN=your_notion_token -e NOTION_PAGE_ID=your_notion_page_id"
   },
   "homepage": "https://github.com/awkoy/notion-mcp-server",
@@ -25,17 +27,21 @@
     "build"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.7.0",
-    "@notionhq/client": "^2.3.0",
-    "zod": "^3.24.2"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@notionhq/client": "^5.22.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",
     "shx": "^0.3.4",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "vitest": "^4.1.7"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "repository": {
     "type": "git",

package/build/resources/imageList.js

@@ -1,62 +0,0 @@
-import { server } from "../server/index.js";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { replicate } from "../services/replicate.js";
-import { urlToBase64 } from "../utils/image.js";
-import { CONFIG } from "../config/index.js";
-export const registerImageListResource = () => {
-    const list = async () => {
-        try {
-            const predictions = [];
-            for await (const page of replicate.paginate(replicate.predictions.list)) {
-                predictions.push(...page);
-            }
-            return {
-                resources: predictions
-                    .filter((prediction) => prediction.output?.length &&
-                    prediction.model === CONFIG.imageModelId)
-                    .map((prediction) => ({
-                    uri: `images://${prediction.id}`,
-                    name: `Image ${prediction.id}`,
-                    mimeType: "application/json",
-                    description: `Generated image by ${prediction.model} with id ${prediction.id}`,
-                })),
-                nextCursor: undefined,
-            };
-        }
-        catch (error) {
-            console.error("Error listing predictions:", error);
-            return {
-                resources: [],
-                nextCursor: undefined,
-            };
-        }
-    };
-    server.resource("images", new ResourceTemplate("images://{id}", {
-        list,
-    }), async (uri, { id }) => {
-        const prediction = await replicate.predictions.get(id);
-        if (!prediction.output?.length) {
-            return {
-                contents: [
-                    {
-                        name: "Not Found!",
-                        uri: uri.href,
-                        text: `Data has been removed by Replicate automatically after an hour, by default. You have to save your own copies before it is removed.`,
-                        mimeType: "text/plain",
-                    },
-                ],
-            };
-        }
-        const imageBase64 = await urlToBase64(prediction.output[0]);
-        return {
-            contents: [
-                {
-                    name: "image",
-                    uri: uri.href,
-                    blob: imageBase64,
-                    mimeType: "image/png",
-                },
-            ],
-        };
-    });
-};

package/build/resources/index.js

@@ -1 +0,0 @@
-export const registerAllResources = () => { };

package/build/resources/predictionList.js

@@ -1,43 +0,0 @@
-import { server } from "../server/index.js";
-import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { replicate } from "../services/replicate.js";
-export const registerPreditionListResource = () => {
-    const list = async () => {
-        try {
-            const predictions = [];
-            for await (const page of replicate.paginate(replicate.predictions.list)) {
-                predictions.push(...page);
-            }
-            return {
-                resources: predictions.map((prediction) => ({
-                    uri: `predictions://${prediction.id}`,
-                    name: `Prediction ${prediction.id}`,
-                    mimeType: "application/json",
-                })),
-                nextCursor: undefined,
-            };
-        }
-        catch (error) {
-            console.error("Error listing predictions:", error);
-            return {
-                resources: [],
-                nextCursor: undefined,
-            };
-        }
-    };
-    server.resource("predictions", new ResourceTemplate("predictions://{id}", {
-        list,
-    }), async (uri, { id }) => {
-        const prediction = await replicate.predictions.get(id);
-        return {
-            contents: [
-                {
-                    name: "prediction",
-                    uri: uri.href,
-                    text: JSON.stringify(prediction),
-                    mimeType: "application/json",
-                },
-            ],
-        };
-    });
-};

package/build/resources/svgList.js

@@ -1,69 +0,0 @@
-// import { server } from "../server/index.js";
-// import {
-//   ListResourcesCallback,
-//   ResourceTemplate,
-// } from "@modelcontextprotocol/sdk/server/mcp.js";
-// import { replicate } from "../services/notion.js";
-// import { urlToSvg } from "../utils/image.js";
-// import { Prediction } from "replicate";
-// import { CONFIG } from "../config/index.js";
-export {};
-// export const registerSvgListResource = () => {
-//   const list: ListResourcesCallback = async () => {
-//     try {
-//       const predictions: Prediction[] = [];
-//       for await (const page of replicate.paginate(replicate.predictions.list)) {
-//         predictions.push(...page);
-//       }
-//       return {
-//         resources: predictions
-//           .filter((prediction) => prediction.model === CONFIG.svgModelId)
-//           .map((prediction) => ({
-//             uri: `svglist://${prediction.id}`,
-//             name: `SVG ${prediction.id}`,
-//             mimeType: "application/json",
-//             description: `Generated image by ${prediction.model} with id ${prediction.id}`,
-//           })),
-//         nextCursor: undefined,
-//       };
-//     } catch (error) {
-//       console.error("Error listing predictions:", error);
-//       return {
-//         resources: [],
-//         nextCursor: undefined,
-//       };
-//     }
-//   };
-//   server.resource(
-//     "svglist",
-//     new ResourceTemplate("svglist://{id}", {
-//       list,
-//     }),
-//     async (uri, { id }) => {
-//       const prediction = await replicate.predictions.get(id as string);
-//       if (!prediction.output) {
-//         return {
-//           contents: [
-//             {
-//               name: "Not Found!",
-//               uri: uri.href,
-//               text: `Data has been removed by Replicate automatically after an hour, by default. You have to save your own copies before it is removed.`,
-//               mimeType: "text/plain",
-//             },
-//           ],
-//         };
-//       }
-//       const svg = await urlToSvg(prediction.output);
-//       return {
-//         contents: [
-//           {
-//             name: "svglist",
-//             uri: uri.href,
-//             text: svg,
-//             mimeType: "image/svg+xml",
-//           },
-//         ],
-//       };
-//     }
-//   );
-// };

package/build/schema/comments.js

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import { RICH_TEXT_ITEM_REQUEST_SCHEMA } from "./rich-text.js";
-// Schema for getting comments
-export const GET_COMMENTS_SCHEMA = {
-    block_id: z
-        .string()
-        .describe("The ID of the block or page to get comments from"),
-    start_cursor: z
-        .string()
-        .optional()
-        .describe("The cursor to start from for pagination"),
-    page_size: z
-        .number()
-        .optional()
-        .describe("Number of comments to return per page"),
-};
-// Schema for adding a comment to a page
-export const ADD_PAGE_COMMENT_SCHEMA = {
-    parent: z.object({
-        page_id: z.string().describe("The ID of the page to add the comment to"),
-    }),
-    rich_text: z
-        .array(RICH_TEXT_ITEM_REQUEST_SCHEMA)
-        .describe("Rich text content for the comment"),
-};
-// Schema for adding a comment to a discussion
-export const ADD_DISCUSSION_COMMENT_SCHEMA = {
-    discussion_id: z
-        .string()
-        .describe("The ID of the discussion to add the comment to"),
-    rich_text: z
-        .array(RICH_TEXT_ITEM_REQUEST_SCHEMA)
-        .describe("Rich text content for the comment"),
-};