improved-notion-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,693 @@
+import { Client } from "@notionhq/client";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+const NOTION_TOKEN = process.env.NOTION_TOKEN || process.env.NOTION_API_KEY;
+if (!NOTION_TOKEN) {
+    console.error("NOTION_TOKEN or NOTION_API_KEY environment variable is required");
+    process.exit(1);
+}
+const notion = new Client({ auth: NOTION_TOKEN });
+function convertBlockToMarkdown(block) {
+    const type = block.type;
+    const data = block[type];
+    switch (type) {
+        case "paragraph":
+            return data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || "";
+        case "heading_1":
+            return `## ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "heading_2":
+            return `### ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "heading_3":
+            return `#### ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "bulleted_list_item":
+            return `- ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "numbered_list_item":
+            return `1. ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "to_do":
+            const checked = data.checked ? "[x]" : "[ ]";
+            return `${checked} ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "toggle":
+            return `> ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "code":
+            const lang = data.language || "";
+            const code = data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || "";
+            return `\`\`\`${lang}\n${code}\n\`\`\``;
+        case "quote":
+            return `> ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "divider":
+            return "---";
+        case "image":
+            const imgUrl = data.file?.url || data.external?.url || "";
+            const imgCaption = data.caption?.map((t) => richTextToMarkdown(t)).join("") || "";
+            return imgCaption ? `![${imgCaption}](${imgUrl})` : `![](${imgUrl})`;
+        case "video":
+            const videoUrl = data.file?.url || data.external?.url || "";
+            return `[Video](${videoUrl})`;
+        case "embed":
+            return `[Embed](${data.url})`;
+        case "link_preview":
+            return `[Link Preview](${data.url})`;
+        case "bookmark":
+            return `[Bookmark](${data.url}) ${data.caption?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "callout":
+            const icon = data.icon?.emoji || "💡";
+            return `${icon} ${data.rich_text?.map((t) => richTextToMarkdown(t)).join("") || ""}`;
+        case "equation":
+            return `$$${data.expression}$$`;
+        default:
+            return `[${type}]`;
+    }
+}
+function richTextToMarkdown(richText) {
+    if (!richText)
+        return "";
+    let text = richText.plain_text || "";
+    if (richText.annotations) {
+        const { bold, italic, strikethrough, code, underline } = richText.annotations;
+        if (code)
+            text = `\`${text}\``;
+        if (bold)
+            text = `**${text}**`;
+        if (italic)
+            text = `*${text}*`;
+        if (strikethrough)
+            text = `~~${text}~~`;
+        if (underline)
+            text = `<u>${text}</u>`;
+    }
+    if (richText.href) {
+        text = `[${text}](${richText.href})`;
+    }
+    return text;
+}
+function convertPageToMarkdown(page) {
+    let md = "";
+    if (page.properties) {
+        const titleProp = Object.values(page.properties).find((p) => p.type === "title");
+        if (titleProp?.title?.length) {
+            md += `# ${titleProp.title.map((t) => t.plain_text).join("")}\n\n`;
+        }
+        md += `---\n`;
+        for (const [key, prop] of Object.entries(page.properties)) {
+            if (prop.type === "title")
+                continue;
+            const propValue = formatProperty(prop);
+            if (propValue) {
+                md += `**${key}**: ${propValue}\n`;
+            }
+        }
+        md += `---\n\n`;
+    }
+    return md;
+}
+function formatProperty(prop) {
+    switch (prop.type) {
+        case "rich_text":
+            return prop.rich_text?.map((t) => t.plain_text).join("") || null;
+        case "url":
+            return prop.url;
+        case "checkbox":
+            return prop.checkbox ? "✅" : "⬜";
+        case "date":
+            return prop.date?.start || null;
+        case "select":
+            return prop.select?.name || null;
+        case "multi_select":
+            return prop.multi_select?.map((s) => s.name).join(", ") || null;
+        case "status":
+            return prop.status?.name || null;
+        case "people":
+            return prop.people?.map((p) => p.name || p.person?.email).join(", ") || null;
+        case "email":
+            return prop.email;
+        case "phone_number":
+            return prop.phone_number;
+        case "number":
+            return prop.number?.toString() || null;
+        default:
+            return null;
+    }
+}
+function getTitle(item) {
+    if (item.properties) {
+        const titleProp = Object.values(item.properties).find((p) => p.type === "title");
+        if (titleProp?.title?.length) {
+            return titleProp.title.map((t) => t.plain_text).join("");
+        }
+    }
+    if (item.name) {
+        return item.name;
+    }
+    return "Untitled";
+}
+function markdownToBlocks(markdown) {
+    const lines = markdown.split("\n");
+    const blocks = [];
+    let currentParagraph = [];
+    let inCodeBlock = false;
+    let codeLanguage = "";
+    let codeContent = [];
+    const flushParagraph = () => {
+        if (currentParagraph.length > 0) {
+            const text = currentParagraph.join(" ").trim();
+            if (text) {
+                blocks.push({
+                    object: "block",
+                    type: "paragraph",
+                    paragraph: {
+                        rich_text: [{ type: "text", text: { content: text } }],
+                    },
+                });
+            }
+            currentParagraph = [];
+        }
+    };
+    for (const line of lines) {
+        if (line.startsWith("```")) {
+            if (!inCodeBlock) {
+                flushParagraph();
+                inCodeBlock = true;
+                codeLanguage = line.slice(3).trim();
+                codeContent = [];
+            }
+            else {
+                blocks.push({
+                    object: "block",
+                    type: "code",
+                    code: {
+                        rich_text: [{ type: "text", text: { content: codeContent.join("\n") } }],
+                        language: codeLanguage || "plain text",
+                    },
+                });
+                inCodeBlock = false;
+                codeLanguage = "";
+                codeContent = [];
+            }
+        }
+        else if (inCodeBlock) {
+            codeContent.push(line);
+        }
+        else if (line.startsWith("## ")) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "heading_2",
+                heading_2: {
+                    rich_text: [{ type: "text", text: { content: line.slice(3) } }],
+                },
+            });
+        }
+        else if (line.startsWith("### ")) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "heading_3",
+                heading_3: {
+                    rich_text: [{ type: "text", text: { content: line.slice(4) } }],
+                },
+            });
+        }
+        else if (line.startsWith("# ")) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "heading_1",
+                heading_1: {
+                    rich_text: [{ type: "text", text: { content: line.slice(2) } }],
+                },
+            });
+        }
+        else if (line.startsWith("- ")) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "bulleted_list_item",
+                bulleted_list_item: {
+                    rich_text: [{ type: "text", text: { content: line.slice(2) } }],
+                },
+            });
+        }
+        else if (line.match(/^\d+\. /)) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "numbered_list_item",
+                numbered_list_item: {
+                    rich_text: [{ type: "text", text: { content: line.replace(/^\d+\. /, "") } }],
+                },
+            });
+        }
+        else if (line.startsWith("> ")) {
+            flushParagraph();
+            blocks.push({
+                object: "block",
+                type: "quote",
+                quote: {
+                    rich_text: [{ type: "text", text: { content: line.slice(2) } }],
+                },
+            });
+        }
+        else if (line === "---") {
+            flushParagraph();
+            blocks.push({ object: "block", type: "divider", divider: {} });
+        }
+        else if (line.trim()) {
+            currentParagraph.push(line);
+        }
+    }
+    flushParagraph();
+    return blocks;
+}
+class NotionMcpServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "improved-notion-mcp",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+            },
+        });
+        this.setupTools();
+        this.setupResources();
+    }
+    setupTools() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "notion_search",
+                        description: "Search for pages and databases in Notion",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                query: { type: "string", description: "Search query" },
+                                filter: {
+                                    type: "string",
+                                    enum: ["page", "database", "all"],
+                                    description: "Filter by type",
+                                },
+                            },
+                            required: ["query"],
+                        },
+                    },
+                    {
+                        name: "notion_get_page",
+                        description: "Get a page's content as markdown (token-optimized)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                pageId: { type: "string", description: "Page ID" },
+                            },
+                            required: ["pageId"],
+                        },
+                    },
+                    {
+                        name: "notion_create_page",
+                        description: "Create a new page in Notion",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                parentId: { type: "string", description: "Parent page ID or database ID" },
+                                title: { type: "string", description: "Page title" },
+                                content: { type: "string", description: "Initial content in markdown" },
+                            },
+                            required: ["parentId", "title"],
+                        },
+                    },
+                    {
+                        name: "notion_create_database_entry",
+                        description: "Create a new entry in a database",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                databaseId: { type: "string", description: "Database ID" },
+                                properties: { type: "object", description: "Database properties" },
+                            },
+                            required: ["databaseId", "properties"],
+                        },
+                    },
+                    {
+                        name: "notion_query_database",
+                        description: "Query a database with filters",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                databaseId: { type: "string", description: "Database ID" },
+                                pageSize: { type: "number", description: "Number of results" },
+                            },
+                            required: ["databaseId"],
+                        },
+                    },
+                    {
+                        name: "notion_update_page",
+                        description: "Update a page's properties or content",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                pageId: { type: "string", description: "Page ID" },
+                                content: { type: "string", description: "Content to add (appended)" },
+                            },
+                            required: ["pageId"],
+                        },
+                    },
+                    {
+                        name: "notion_batch_create",
+                        description: "Create multiple pages at once (batch operation)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                parentId: { type: "string", description: "Parent page ID" },
+                                pages: {
+                                    type: "array",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            title: { type: "string" },
+                                            content: { type: "string" },
+                                        },
+                                        required: ["title"],
+                                    },
+                                    description: "Array of pages to create",
+                                },
+                            },
+                            required: ["parentId", "pages"],
+                        },
+                    },
+                    {
+                        name: "notion_append_content",
+                        description: "Append content to a page (composite operation)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                pageId: { type: "string", description: "Page ID" },
+                                markdown: { type: "string", description: "Markdown content to append" },
+                            },
+                            required: ["pageId", "markdown"],
+                        },
+                    },
+                    {
+                        name: "notion_delete_page",
+                        description: "Delete (archive) a page",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                pageId: { type: "string", description: "Page ID to delete" },
+                            },
+                            required: ["pageId"],
+                        },
+                    },
+                    {
+                        name: "notion_list_databases",
+                        description: "List all accessible databases",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                    {
+                        name: "notion_get_database_schema",
+                        description: "Get database schema (properties)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                databaseId: { type: "string", description: "Database ID" },
+                            },
+                            required: ["databaseId"],
+                        },
+                    },
+                    {
+                        name: "notion_list_users",
+                        description: "List users in the workspace",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "notion_search":
+                        return await this.handleSearch(args);
+                    case "notion_get_page":
+                        return await this.handleGetPage(args);
+                    case "notion_create_page":
+                        return await this.handleCreatePage(args);
+                    case "notion_create_database_entry":
+                        return await this.handleCreateDatabaseEntry(args);
+                    case "notion_query_database":
+                        return await this.handleQueryDatabase(args);
+                    case "notion_update_page":
+                        return await this.handleUpdatePage(args);
+                    case "notion_batch_create":
+                        return await this.handleBatchCreate(args);
+                    case "notion_append_content":
+                        return await this.handleAppendContent(args);
+                    case "notion_delete_page":
+                        return await this.handleDeletePage(args);
+                    case "notion_list_databases":
+                        return await this.handleListDatabases();
+                    case "notion_get_database_schema":
+                        return await this.handleGetDatabaseSchema(args);
+                    case "notion_list_users":
+                        return await this.handleListUsers();
+                    default:
+                        return this.errorResult(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return this.errorResult(error.message);
+            }
+        });
+    }
+    setupResources() {
+        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+            return {
+                resources: [
+                    {
+                        uri: "notion://docs",
+                        name: "Notion MCP documentation",
+                        description: "Documentation for available tools",
+                        mimeType: "text/markdown",
+                    },
+                ],
+            };
+        });
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+            const { uri } = request.params;
+            if (uri === "notion://docs") {
+                return {
+                    contents: [
+                        {
+                            uri: "notion://docs",
+                            mimeType: "text/markdown",
+                            text: `# Notion MCP Server Tools
+
+## Available Tools
+
+### Search & Discovery
+- \`notion_search\` - Search pages and databases
+- \`notion_list_databases\` - List all databases
+- \`notion_list_users\` - List workspace users
+
+### Read Operations
+- \`notion_get_page\` - Get page as markdown (token-optimized ~80% reduction)
+- \`notion_get_database_schema\` - Get database schema
+- \`notion_query_database\` - Query database with filters
+
+### Write Operations
+- \`notion_create_page\` - Create a new page
+- \`notion_create_database_entry\` - Create database entry
+- \`notion_update_page\` - Update page properties/content
+- \`notion_append_content\` - Append markdown to page
+
+### Batch & Composite Operations
+- \`notion_batch_create\` - Create multiple pages at once
+
+### Delete Operations
+- \`notion_delete_page\` - Archive a page
+
+## Token Optimization
+All read operations return markdown instead of raw JSON, reducing token usage by ~80%.
+`,
+                        },
+                    ],
+                };
+            }
+            return { contents: [] };
+        });
+    }
+    async handleSearch(args) {
+        const response = await notion.search({
+            query: args.query,
+            // @ts-ignore - Notion API typing issue
+            filter: args.filter !== "all" && args.filter ? { value: args.filter, property: "object" } : undefined,
+            page_size: 20,
+        });
+        const results = response.results.map((item) => ({
+            id: item.id,
+            type: item.object,
+            title: getTitle(item),
+            url: item.url,
+            created_time: item.created_time,
+        }));
+        return this.successResult(JSON.stringify(results, null, 2));
+    }
+    async handleGetPage(args) {
+        const page = await notion.pages.retrieve({ page_id: args.pageId });
+        let md = convertPageToMarkdown(page);
+        const blocks = await notion.blocks.children.list({ block_id: args.pageId });
+        for (const block of blocks.results) {
+            md += convertBlockToMarkdown(block) + "\n";
+        }
+        return this.successResult(md);
+    }
+    async handleCreatePage(args) {
+        const blocks = args.content ? markdownToBlocks(args.content) : [];
+        const page = await notion.pages.create({
+            parent: { page_id: args.parentId },
+            properties: {
+                title: {
+                    title: [{ text: { content: args.title } }],
+                },
+            },
+        });
+        if (blocks.length > 0) {
+            await notion.blocks.children.append({
+                block_id: page.id,
+                children: blocks,
+            });
+        }
+        const url = page.url || `https://notion.so/${page.id.replace(/-/g, '')}`;
+        return this.successResult(JSON.stringify({ id: page.id, url }, null, 2));
+    }
+    async handleCreateDatabaseEntry(args) {
+        const page = await notion.pages.create({
+            parent: { database_id: args.databaseId },
+            properties: args.properties,
+        });
+        const url = page.url || `https://notion.so/${page.id.replace(/-/g, '')}`;
+        return this.successResult(JSON.stringify({ id: page.id, url }, null, 2));
+    }
+    async handleQueryDatabase(args) {
+        // @ts-ignore - Notion SDK typing issue
+        const response = await notion.databases.query({
+            database_id: args.databaseId,
+            page_size: args.pageSize || 20,
+        });
+        const results = response.results.map((page) => ({
+            id: page.id,
+            title: getTitle(page),
+            url: page.url,
+            properties: page.properties,
+        }));
+        return this.successResult(JSON.stringify(results, null, 2));
+    }
+    async handleUpdatePage(args) {
+        if (args.content) {
+            const blocks = markdownToBlocks(args.content);
+            await notion.blocks.children.append({
+                block_id: args.pageId,
+                children: blocks,
+            });
+        }
+        return this.successResult("Page updated successfully");
+    }
+    async handleBatchCreate(args) {
+        const results = [];
+        for (const page of args.pages) {
+            const pageData = {
+                parent: { page_id: args.parentId },
+                properties: {
+                    title: {
+                        title: [{ text: { content: page.title } }],
+                    },
+                },
+            };
+            const created = await notion.pages.create(pageData);
+            if (page.content) {
+                const blocks = markdownToBlocks(page.content);
+                await notion.blocks.children.append({
+                    block_id: created.id,
+                    children: blocks,
+                });
+            }
+            const url = created.url || `https://notion.so/${created.id.replace(/-/g, '')}`;
+            results.push({ id: created.id, title: page.title, url });
+        }
+        return this.successResult(JSON.stringify(results, null, 2));
+    }
+    async handleAppendContent(args) {
+        const blocks = markdownToBlocks(args.markdown);
+        await notion.blocks.children.append({
+            block_id: args.pageId,
+            children: blocks,
+        });
+        return this.successResult("Content appended successfully");
+    }
+    async handleDeletePage(args) {
+        await notion.pages.update({
+            page_id: args.pageId,
+            archived: true,
+        });
+        return this.successResult("Page archived successfully");
+    }
+    async handleListDatabases() {
+        const response = await notion.search({
+            filter: { value: "page", property: "object" },
+            page_size: 50,
+        });
+        const databases = response.results
+            .filter((item) => item.object === "page" && item.parent?.type === "workspace")
+            .map((db) => ({
+            id: db.id,
+            title: getTitle(db),
+            url: db.url,
+        }));
+        return this.successResult(JSON.stringify(databases, null, 2));
+    }
+    async handleGetDatabaseSchema(args) {
+        const db = await notion.databases.retrieve({ database_id: args.databaseId });
+        return this.successResult(JSON.stringify(db, null, 2));
+    }
+    async handleListUsers() {
+        // @ts-ignore - Notion SDK typing issue
+        const response = await notion.users.list({});
+        const users = response.results.map((user) => ({
+            id: user.id,
+            name: user.name,
+            type: user.type,
+            email: user.person?.email,
+        }));
+        return this.successResult(JSON.stringify(users, null, 2));
+    }
+    successResult(text) {
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    errorResult(message) {
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+    async run(transport) {
+        await this.server.connect(transport);
+        await transport.start();
+    }
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    const server = new NotionMcpServer();
+    await server.run(transport);
+}
+main().catch(console.error);
+//# sourceMappingURL=index.js.map