notion-mcp-server 0.0.2 → 1.0.1

package/README.md

@@ -9,7 +9,7 @@
 
 **Notion MCP Server** is a Model Context Protocol (MCP) server implementation that enables AI assistants to interact with Notion's API. This production-ready server provides a complete set of tools and endpoints for reading, creating, and modifying Notion content through natural language interactions.
 
-> 🚧 **Active Development**: Database support is now available! If you find this project useful, please consider giving it a star - it helps me know that this work is valuable to the community and motivates further development.
+> 🚧 **Active Development**: Database support is now available! Comments and user management tools have been added. If you find this project useful, please consider giving it a star - it helps me know that this work is valuable to the community and motivates further development.
 
 <a href="https://glama.ai/mcp/servers/zrh07hteaa">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zrh07hteaa/badge" />
@@ -56,6 +56,10 @@
    - "Add bullet points to my meeting notes page"
    - "Create a new database for tracking projects"
    - "Add new entries to my task database"
+   - "Add a comment to my project page"
+   - "Show me all comments on this document"
+   - "List all users in my workspace"
+   - "Get information about a specific user"
 
 ### Cursor Integration
 
@@ -124,6 +128,8 @@ env NOTION_TOKEN=YOUR_KEY NOTION_PAGE_ID=YOUR_PAGE_ID npx -y notion-mcp-server
 - **🔄 Batch Operations** - Perform multiple operations in a single request
 - **🗑️ Archive & Restore** - Archive and restore Notion pages
 - **🔎 Search Functionality** - Search Notion pages and databases by title
+- **💬 Comments Management** - Get, create, and reply to comments on pages and discussions
+- **👥 User Management** - Retrieve workspace users and user information
 
 ## 📚 Documentation
 
@@ -190,6 +196,28 @@ Delete multiple blocks in a single operation
 ##### `batch_mixed_operations`
 Perform a mix of append, update, and delete operations in a single request
 
+#### Comment Operations
+
+##### `get_comments`
+Retrieve comments from a page or block with pagination support
+
+##### `add_page_comment`
+Add a new comment to a Notion page
+
+##### `add_discussion_comment`
+Add a comment to an existing discussion thread
+
+#### User Operations
+
+##### `get_list_users`
+Retrieve a paginated list of all users in the workspace
+
+##### `get_user`
+Get detailed information about a specific user by ID
+
+##### `get_bot_user`
+Retrieve the current bot user associated with the API token
+
 ### Available Resources
 
 The server currently does not expose any resources, focusing instead on tool-based operations.

package/build/config/index.js

@@ -1,5 +1,5 @@
 // Configuration
 export const CONFIG = {
     serverName: "notion-mcp-server",
-    serverVersion: "0.0.2",
+    serverVersion: "1.0.1",
 };

package/build/schema/blocks.js

@@ -207,3 +207,64 @@ export const BATCH_MIXED_OPERATIONS_SCHEMA = {
     ]))
         .describe("Array of mixed operations to perform in a single batch"),
 };
+// Combined schema for all block operations
+export const BLOCKS_OPERATION_SCHEMA = {
+    payload: z
+        .preprocess(preprocessJson, z.discriminatedUnion("action", [
+        z.object({
+            action: z
+                .literal("append_block_children")
+                .describe("Use this action to append children to a block."),
+            params: z.object(APPEND_BLOCK_CHILDREN_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("retrieve_block")
+                .describe("Use this action to retrieve a block."),
+            params: z.object(RETRIEVE_BLOCK_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("retrieve_block_children")
+                .describe("Use this action to retrieve children of a block."),
+            params: z.object(RETRIEVE_BLOCK_CHILDREN_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("update_block")
+                .describe("Use this action to update a block."),
+            params: z.object(UPDATE_BLOCK_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("delete_block")
+                .describe("Use this action to delete/archive a block."),
+            params: z.object(DELETE_BLOCK_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("batch_append_block_children")
+                .describe("Use this action to perform batch append operations on blocks."),
+            params: z.object(BATCH_APPEND_BLOCK_CHILDREN_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("batch_update_blocks")
+                .describe("Use this action to perform batch update operations on blocks."),
+            params: z.object(BATCH_UPDATE_BLOCKS_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("batch_delete_blocks")
+                .describe("Use this action to perform batch delete operations on blocks."),
+            params: z.object(BATCH_DELETE_BLOCKS_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("batch_mixed_operations")
+                .describe("Use this action to perform batch mixed operations on blocks."),
+            params: z.object(BATCH_MIXED_OPERATIONS_SCHEMA),
+        }),
+    ]))
+        .describe("A union of all possible block operations. Each operation has a specific action and corresponding parameters. Use this schema to validate the input for block operations such as appending, retrieving, updating, deleting, and performing batch operations. Available actions include: 'append_block_children', 'retrieve_block', 'retrieve_block_children', 'update_block', 'delete_block', 'batch_append_block_children', 'batch_update_blocks', 'batch_delete_blocks', and 'batch_mixed_operations'. Each operation requires specific parameters as defined in the corresponding schemas."),
+};

package/build/schema/comments.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { RICH_TEXT_ITEM_REQUEST_SCHEMA } from "./rich-text.js";
+import { preprocessJson } from "./preprocess.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"),
+};
+// Combined schema for all comment operations
+export const COMMENTS_OPERATION_SCHEMA = {
+    payload: z
+        .preprocess(preprocessJson, z.discriminatedUnion("action", [
+        z.object({
+            action: z
+                .literal("get_comments")
+                .describe("Use this action to get comments from a block or page."),
+            params: z.object(GET_COMMENTS_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("add_page_comment")
+                .describe("Use this action to add a comment to a page."),
+            params: z.object(ADD_PAGE_COMMENT_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("add_discussion_comment")
+                .describe("Use this action to add a comment to a discussion."),
+            params: z.object(ADD_DISCUSSION_COMMENT_SCHEMA),
+        }),
+    ]))
+        .describe("A union of all possible comment operations. Each operation has a specific action and corresponding parameters. Use this schema to validate the input for comment operations such as getting, adding to page, and adding to discussion. Available actions include: 'get_comments', 'add_page_comment', and 'add_discussion_comment'. Each operation requires specific parameters as defined in the corresponding schemas."),
+};

package/build/schema/database.js

@@ -339,3 +339,28 @@ export const UPDATE_DATABASE_SCHEMA = {
         .optional()
         .describe("Updated cover image for the database")),
 };
+// Combined schema for all database operations
+export const DATABASE_OPERATION_SCHEMA = {
+    payload: z
+        .preprocess(preprocessJson, z.discriminatedUnion("action", [
+        z.object({
+            action: z
+                .literal("create_database")
+                .describe("Use this action to create a new database."),
+            params: z.object(CREATE_DATABASE_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("query_database")
+                .describe("Use this action to query a database."),
+            params: z.object(QUERY_DATABASE_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("update_database")
+                .describe("Use this action to update a database."),
+            params: z.object(UPDATE_DATABASE_SCHEMA),
+        }),
+    ]))
+        .describe("A union of all possible database operations. Each operation has a specific action and corresponding parameters. Use this schema to validate the input for database operations such as creating, querying, and updating databases. Available actions include: 'create_database', 'query_database', and 'update_database'. Each operation requires specific parameters as defined in the corresponding schemas."),
+};

package/build/schema/page.js

@@ -97,3 +97,40 @@ export const SEARCH_PAGES_SCHEMA = {
         .optional()
         .describe("Number of results to return (1-100)"),
 };
+// Combined schema for all page operations
+export const PAGES_OPERATION_SCHEMA = {
+    payload: z
+        .preprocess(preprocessJson, z.discriminatedUnion("action", [
+        z.object({
+            action: z
+                .literal("create_page")
+                .describe("Use this action to create a new page in the database."),
+            params: z.object(CREATE_PAGE_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("archive_page")
+                .describe("Use this action to archive an existing page, making it inactive."),
+            params: z.object(ARCHIVE_PAGE_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("restore_page")
+                .describe("Use this action to restore a previously archived page."),
+            params: z.object(RESTORE_PAGE_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("search_pages")
+                .describe("Use this action to search for pages based on a query."),
+            params: z.object(SEARCH_PAGES_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("update_page_properties")
+                .describe("Use this action to update the properties of an existing page."),
+            params: z.object(UPDATE_PAGE_PROPERTIES_SCHEMA),
+        }),
+    ]))
+        .describe("A union of all possible page operations. Each operation has a specific action and corresponding parameters. Use this schema to validate the input for page operations such as creating, archiving, restoring, searching, and updating pages. Available actions include: 'create_page', 'archive_page', 'restore_page', 'search_pages', and 'update_page_properties'. Each operation requires specific parameters as defined in the corresponding schemas."),
+};

package/build/schema/users.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { preprocessJson } from "./preprocess.js";
+// Schema for listing users with pagination
+export const LIST_USERS_SCHEMA = {
+    start_cursor: z.string().optional().describe("Pagination cursor"),
+    page_size: z
+        .number()
+        .optional()
+        .describe("Number of users to return per page"),
+};
+// Schema for getting a single user
+export const GET_USER_SCHEMA = {
+    user_id: z.string().describe("The ID of the user to retrieve"),
+};
+// Combined schema for all user operations
+export const USERS_OPERATION_SCHEMA = {
+    payload: z
+        .preprocess(preprocessJson, z.discriminatedUnion("action", [
+        z.object({
+            action: z
+                .literal("list_users")
+                .describe("Use this action to list users."),
+            params: z.object(LIST_USERS_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("get_user")
+                .describe("Use this action to get a single user."),
+            params: z.object(GET_USER_SCHEMA),
+        }),
+        z.object({
+            action: z
+                .literal("get_bot_user")
+                .describe("Use this action to get the bot user."),
+            params: z.object({}),
+        }),
+    ]))
+        .describe("A union of all possible user operations. Each operation has a specific action and corresponding parameters. Use this schema to validate the input for user operations such as listing, getting a single user, and getting the bot user. Available actions include: 'list_users', 'get_user', and 'get_bot_user'. Each operation requires specific parameters as defined in the corresponding schemas."),
+};

package/build/server/index.js

@@ -18,7 +18,7 @@ export async function startServer() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error(`${CONFIG.serverName} v${CONFIG.serverVersion} running on stdio`);
+        console.log(`${CONFIG.serverName} v${CONFIG.serverVersion} running on stdio`);
     }
     catch (error) {
         console.error("Server initialization error:", error instanceof Error ? error.message : String(error));

package/build/services/loggs.js

@@ -0,0 +1,13 @@
+export function sendLog(level, message, data = null) {
+    fetch("http://localhost:4400/api/log", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            level, // 'debug', 'info', 'warn', 'error'
+            message,
+            data, // Optional additional data object or string
+        }),
+    }).catch((error) => console.error("Error sending log:", error));
+}

package/build/tools/blocks.js

@@ -0,0 +1,34 @@
+import { handleNotionError } from "../utils/error.js";
+import { appendBlockChildren } from "./appendBlockChildren.js";
+import { retrieveBlock } from "./retrieveBlock.js";
+import { retrieveBlockChildren } from "./retrieveBlockChildren.js";
+import { updateBlock } from "./updateBlock.js";
+import { deleteBlock } from "./deleteBlock.js";
+import { batchAppendBlockChildren } from "./batchAppendBlockChildren.js";
+import { batchUpdateBlocks } from "./batchUpdateBlocks.js";
+import { batchDeleteBlocks } from "./batchDeleteBlocks.js";
+import { batchMixedOperations } from "./batchMixedOperations.js";
+export const registerBlocksOperationTool = async (params) => {
+    switch (params.payload.action) {
+        case "append_block_children":
+            return appendBlockChildren(params.payload.params);
+        case "retrieve_block":
+            return retrieveBlock(params.payload.params);
+        case "retrieve_block_children":
+            return retrieveBlockChildren(params.payload.params);
+        case "update_block":
+            return updateBlock(params.payload.params);
+        case "delete_block":
+            return deleteBlock(params.payload.params);
+        case "batch_append_block_children":
+            return batchAppendBlockChildren(params.payload.params);
+        case "batch_update_blocks":
+            return batchUpdateBlocks(params.payload.params);
+        case "batch_delete_blocks":
+            return batchDeleteBlocks(params.payload.params);
+        case "batch_mixed_operations":
+            return batchMixedOperations(params.payload.params);
+        default:
+            return handleNotionError(new Error(`Unsupported action, use one of the following: "append_block_children", "retrieve_block", "retrieve_block_children", "update_block", "delete_block", "batch_append_block_children", "batch_update_blocks", "batch_delete_blocks", "batch_mixed_operations"`));
+    }
+};

package/build/tools/comments.js

@@ -0,0 +1,81 @@
+import { notion } from "../services/notion.js";
+import { handleNotionError } from "../utils/error.js";
+const registerGetCommentsTool = async (params) => {
+    try {
+        const response = await notion.comments.list(params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Comments retrieved successfully: ${response.results.length}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+const registerAddPageCommentTool = async (params) => {
+    try {
+        const response = await notion.comments.create(params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Comment created successfully: ${response.id}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+const registerAddDiscussionCommentTool = async (params) => {
+    try {
+        const response = await notion.comments.create(params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Comment created successfully: ${response.id}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+// Combined tool function that handles all comment operations
+export const registerCommentsOperationTool = async (params) => {
+    try {
+        const { payload } = params;
+        switch (payload.action) {
+            case "get_comments":
+                return registerGetCommentsTool(payload.params);
+            case "add_page_comment":
+                return registerAddPageCommentTool(payload.params);
+            case "add_discussion_comment":
+                return registerAddDiscussionCommentTool(payload.params);
+            default:
+                throw new Error(`Unsupported action, use one of the following: "get_comments", "add_page_comment", "add_discussion_comment"`);
+        }
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};

package/build/tools/database.js

@@ -0,0 +1,16 @@
+import { handleNotionError } from "../utils/error.js";
+import { createDatabase } from "./createDatabase.js";
+import { queryDatabase } from "./queryDatabase.js";
+import { updateDatabase } from "./updateDatabase.js";
+export const registerDatabaseOperationTool = async (params) => {
+    switch (params.payload.action) {
+        case "create_database":
+            return createDatabase(params.payload.params);
+        case "query_database":
+            return queryDatabase(params.payload.params);
+        case "update_database":
+            return updateDatabase(params.payload.params);
+        default:
+            return handleNotionError(new Error(`Unsupported action, use one of the following: "create_database", "query_database", "update_database"`));
+    }
+};

package/build/tools/index.js

@@ -1,41 +1,23 @@
 import { server } from "../server/index.js";
-import { CREATE_PAGE_SCHEMA, ARCHIVE_PAGE_SCHEMA, RESTORE_PAGE_SCHEMA, SEARCH_PAGES_SCHEMA, UPDATE_PAGE_PROPERTIES_SCHEMA, } from "../schema/page.js";
-import { APPEND_BLOCK_CHILDREN_SCHEMA, RETRIEVE_BLOCK_SCHEMA, RETRIEVE_BLOCK_CHILDREN_SCHEMA, UPDATE_BLOCK_SCHEMA, DELETE_BLOCK_SCHEMA, BATCH_APPEND_BLOCK_CHILDREN_SCHEMA, BATCH_UPDATE_BLOCKS_SCHEMA, BATCH_DELETE_BLOCKS_SCHEMA, BATCH_MIXED_OPERATIONS_SCHEMA, } from "../schema/blocks.js";
-import { CREATE_DATABASE_SCHEMA, QUERY_DATABASE_SCHEMA, UPDATE_DATABASE_SCHEMA, } from "../schema/database.js";
-import { archivePage, restorePage } from "./updatePage.js";
-import { registerCreatePageTool } from "./createPage.js";
-import { searchPages } from "./searchPage.js";
-import { appendBlockChildren } from "./appendBlockChildren.js";
-import { retrieveBlock } from "./retrieveBlock.js";
-import { retrieveBlockChildren } from "./retrieveBlockChildren.js";
-import { updateBlock } from "./updateBlock.js";
-import { deleteBlock } from "./deleteBlock.js";
-import { batchAppendBlockChildren } from "./batchAppendBlockChildren.js";
-import { batchUpdateBlocks } from "./batchUpdateBlocks.js";
-import { batchDeleteBlocks } from "./batchDeleteBlocks.js";
-import { batchMixedOperations } from "./batchMixedOperations.js";
-import { createDatabase } from "./createDatabase.js";
-import { queryDatabase } from "./queryDatabase.js";
-import { updateDatabase } from "./updateDatabase.js";
-import { updatePageProperties } from "./updatePageProperties.js";
+import { PAGES_OPERATION_SCHEMA } from "../schema/page.js";
+import { BLOCKS_OPERATION_SCHEMA } from "../schema/blocks.js";
+import { DATABASE_OPERATION_SCHEMA } from "../schema/database.js";
+import { COMMENTS_OPERATION_SCHEMA } from "../schema/comments.js";
+import { USERS_OPERATION_SCHEMA } from "../schema/users.js";
+import { registerPagesOperationTool } from "./pages.js";
+import { registerBlocksOperationTool } from "./blocks.js";
+import { registerDatabaseOperationTool } from "./database.js";
+import { registerCommentsOperationTool } from "./comments.js";
+import { registerUsersOperationTool } from "./users.js";
 export const registerAllTools = () => {
-    server.tool("create_page", "Create a new page in Notion", CREATE_PAGE_SCHEMA, registerCreatePageTool);
-    server.tool("archive_page", "Archive (trash) a Notion page", ARCHIVE_PAGE_SCHEMA, archivePage);
-    server.tool("update_page_properties", "Update the properties of a Notion page", UPDATE_PAGE_PROPERTIES_SCHEMA, updatePageProperties);
-    server.tool("restore_page", "Restore a previously archived Notion page", RESTORE_PAGE_SCHEMA, restorePage);
-    server.tool("search_pages", "Search for pages and databases in Notion by title", SEARCH_PAGES_SCHEMA, searchPages);
-    server.tool("append_block_children", "Append child blocks to a parent block in Notion", APPEND_BLOCK_CHILDREN_SCHEMA, appendBlockChildren);
-    server.tool("retrieve_block", "Retrieve a block from Notion by ID", RETRIEVE_BLOCK_SCHEMA, retrieveBlock);
-    server.tool("retrieve_block_children", "Retrieve the children of a block from Notion", RETRIEVE_BLOCK_CHILDREN_SCHEMA, retrieveBlockChildren);
-    server.tool("update_block", "Update a block's content in Notion", UPDATE_BLOCK_SCHEMA, updateBlock);
-    server.tool("delete_block", "Delete (move to trash) a block in Notion", DELETE_BLOCK_SCHEMA, deleteBlock);
-    // Register database tools
-    server.tool("create_database", "Create a new database in Notion", CREATE_DATABASE_SCHEMA, createDatabase);
-    server.tool("query_database", "Query a database in Notion", QUERY_DATABASE_SCHEMA, queryDatabase);
-    server.tool("update_database", "Update a database in Notion", UPDATE_DATABASE_SCHEMA, updateDatabase);
-    // Register batch operation tools
-    server.tool("batch_append_block_children", "Append children to multiple blocks in a single operation", BATCH_APPEND_BLOCK_CHILDREN_SCHEMA, batchAppendBlockChildren);
-    server.tool("batch_update_blocks", "Update multiple blocks in a single operation", BATCH_UPDATE_BLOCKS_SCHEMA, batchUpdateBlocks);
-    server.tool("batch_delete_blocks", "Delete multiple blocks in a single operation", BATCH_DELETE_BLOCKS_SCHEMA, batchDeleteBlocks);
-    server.tool("batch_mixed_operations", "Perform a mix of append, update, and delete operations in a single request", BATCH_MIXED_OPERATIONS_SCHEMA, batchMixedOperations);
+    // Register combined pages operation tool
+    server.tool("notion_pages", "Perform various page operations (create, archive, restore, search, update)", PAGES_OPERATION_SCHEMA, registerPagesOperationTool);
+    // Register combined blocks operation tool
+    server.tool("notion_blocks", "Perform various block operations (retrieve, update, delete, append children, batch operations)", BLOCKS_OPERATION_SCHEMA, registerBlocksOperationTool);
+    // Register combined database operation tool
+    server.tool("notion_database", "Perform various database operations (create, query, update)", DATABASE_OPERATION_SCHEMA, registerDatabaseOperationTool);
+    // Register combined comments operation tool
+    server.tool("notion_comments", "Perform various comment operations (get, add to page, add to discussion)", COMMENTS_OPERATION_SCHEMA, registerCommentsOperationTool);
+    // Register combined users operation tool
+    server.tool("notion_users", "Perform various user operations (list, get, get bot)", USERS_OPERATION_SCHEMA, registerUsersOperationTool);
 };

package/build/tools/pages.js

@@ -0,0 +1,22 @@
+import { handleNotionError } from "../utils/error.js";
+import { registerCreatePageTool } from "./createPage.js";
+import { archivePage } from "./updatePage.js";
+import { restorePage } from "./updatePage.js";
+import { searchPages } from "./searchPage.js";
+import { updatePageProperties } from "./updatePageProperties.js";
+export const registerPagesOperationTool = async (params) => {
+    switch (params.payload.action) {
+        case "create_page":
+            return registerCreatePageTool(params.payload.params);
+        case "archive_page":
+            return archivePage(params.payload.params);
+        case "restore_page":
+            return restorePage(params.payload.params);
+        case "search_pages":
+            return searchPages(params.payload.params);
+        case "update_page_properties":
+            return updatePageProperties(params.payload.params);
+        default:
+            return handleNotionError(new Error(`Unsupported action, use one of the following: "create_page", "archive_page", "restore_page", "search_pages", "update_page_properties"`));
+    }
+};

package/build/tools/searchPage.js

@@ -4,10 +4,6 @@ export async function searchPages(params) {
     try {
         const response = await notion.search({
             query: params.query || "",
-            filter: {
-                value: "page",
-                property: "object",
-            },
             sort: params.sort,
             start_cursor: params.start_cursor,
             page_size: params.page_size || 10,

package/build/tools/users.js

@@ -0,0 +1,75 @@
+import { notion } from "../services/notion.js";
+import { handleNotionError } from "../utils/error.js";
+export const registerGetListUsersTool = async (params) => {
+    try {
+        const response = await notion.users.list(params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Users retrieved successfully: ${response.results.length}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+export const registerGetUserTool = async (params) => {
+    try {
+        const response = await notion.users.retrieve(params);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `User retrieved successfully: ${response.id}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+export const registerGetBotUserTool = async () => {
+    try {
+        const response = await notion.users.me({});
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Bot user retrieved successfully: ${response.id}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return handleNotionError(error);
+    }
+};
+// Combined tool function that handles all user operations
+export const registerUsersOperationTool = async (params) => {
+    switch (params.payload.action) {
+        case "list_users":
+            return registerGetListUsersTool(params.payload.params);
+        case "get_user":
+            return registerGetUserTool(params.payload.params);
+        case "get_bot_user":
+            return registerGetBotUserTool();
+        default:
+            return handleNotionError(new Error(`Unsupported action, use one of the following: "list_users", "get_user", "get_bot_user"`));
+    }
+};

package/build/types/blocks.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { APPEND_BLOCK_CHILDREN_SCHEMA, RETRIEVE_BLOCK_SCHEMA, RETRIEVE_BLOCK_CHILDREN_SCHEMA, UPDATE_BLOCK_SCHEMA, DELETE_BLOCK_SCHEMA, BATCH_APPEND_BLOCK_CHILDREN_SCHEMA, BATCH_UPDATE_BLOCKS_SCHEMA, BATCH_DELETE_BLOCKS_SCHEMA, BATCH_MIXED_OPERATIONS_SCHEMA, } from "../schema/blocks.js";
+import { APPEND_BLOCK_CHILDREN_SCHEMA, RETRIEVE_BLOCK_SCHEMA, RETRIEVE_BLOCK_CHILDREN_SCHEMA, UPDATE_BLOCK_SCHEMA, DELETE_BLOCK_SCHEMA, BATCH_APPEND_BLOCK_CHILDREN_SCHEMA, BATCH_UPDATE_BLOCKS_SCHEMA, BATCH_DELETE_BLOCKS_SCHEMA, BATCH_MIXED_OPERATIONS_SCHEMA, BLOCKS_OPERATION_SCHEMA, } from "../schema/blocks.js";
 export const appendBlockChildrenSchema = z.object(APPEND_BLOCK_CHILDREN_SCHEMA);
 export const retrieveBlockSchema = z.object(RETRIEVE_BLOCK_SCHEMA);
 export const retrieveBlockChildrenSchema = z.object(RETRIEVE_BLOCK_CHILDREN_SCHEMA);
@@ -9,3 +9,4 @@ export const batchAppendBlockChildrenSchema = z.object(BATCH_APPEND_BLOCK_CHILDR
 export const batchUpdateBlocksSchema = z.object(BATCH_UPDATE_BLOCKS_SCHEMA);
 export const batchDeleteBlocksSchema = z.object(BATCH_DELETE_BLOCKS_SCHEMA);
 export const batchMixedOperationsSchema = z.object(BATCH_MIXED_OPERATIONS_SCHEMA);
+export const blocksOperationSchema = z.object(BLOCKS_OPERATION_SCHEMA);

package/build/types/comments.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { GET_COMMENTS_SCHEMA, ADD_PAGE_COMMENT_SCHEMA, ADD_DISCUSSION_COMMENT_SCHEMA, COMMENTS_OPERATION_SCHEMA, } from "../schema/comments.js";
+// Types inferred from the schemas
+export const getCommentsSchema = z.object(GET_COMMENTS_SCHEMA);
+export const addPageCommentSchema = z.object(ADD_PAGE_COMMENT_SCHEMA);
+export const addDiscussionCommentSchema = z.object(ADD_DISCUSSION_COMMENT_SCHEMA);
+export const commentsOperationSchema = z.object(COMMENTS_OPERATION_SCHEMA);

package/build/types/database.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { CREATE_DATABASE_SCHEMA, QUERY_DATABASE_SCHEMA, UPDATE_DATABASE_SCHEMA, } from "../schema/database.js";
+import { CREATE_DATABASE_SCHEMA, QUERY_DATABASE_SCHEMA, UPDATE_DATABASE_SCHEMA, DATABASE_OPERATION_SCHEMA, } from "../schema/database.js";
 export const createDatabaseSchema = z.object(CREATE_DATABASE_SCHEMA);
 export const queryDatabaseSchema = z.object(QUERY_DATABASE_SCHEMA);
 export const updateDatabaseSchema = z.object(UPDATE_DATABASE_SCHEMA);
+export const databaseOperationSchema = z.object(DATABASE_OPERATION_SCHEMA);

package/build/types/page.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { ARCHIVE_PAGE_SCHEMA, CREATE_PAGE_SCHEMA, RESTORE_PAGE_SCHEMA, SEARCH_PAGES_SCHEMA, UPDATE_PAGE_PROPERTIES_SCHEMA, } from "../schema/page.js";
+import { ARCHIVE_PAGE_SCHEMA, CREATE_PAGE_SCHEMA, RESTORE_PAGE_SCHEMA, SEARCH_PAGES_SCHEMA, UPDATE_PAGE_PROPERTIES_SCHEMA, PAGES_OPERATION_SCHEMA, } from "../schema/page.js";
 export const createPageSchema = z.object(CREATE_PAGE_SCHEMA);
 export const archivePageSchema = z.object(ARCHIVE_PAGE_SCHEMA);
 export const restorePageSchema = z.object(RESTORE_PAGE_SCHEMA);
 export const searchPagesSchema = z.object(SEARCH_PAGES_SCHEMA);
 export const updatePagePropertiesSchema = z.object(UPDATE_PAGE_PROPERTIES_SCHEMA);
+export const pagesOperationSchema = z.object(PAGES_OPERATION_SCHEMA);

package/build/types/users.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+import { LIST_USERS_SCHEMA, GET_USER_SCHEMA, USERS_OPERATION_SCHEMA, } from "../schema/users.js";
+// Types inferred from schemas
+const listUsersSchema = z.object(LIST_USERS_SCHEMA);
+const getUserSchema = z.object(GET_USER_SCHEMA);
+const usersOperationSchema = z.object(USERS_OPERATION_SCHEMA);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notion-mcp-server",
-  "version": "0.0.2",
+  "version": "1.0.1",
   "type": "module",
   "bin": {
     "notion-mcp-server": "build/index.js"
@@ -25,7 +25,7 @@
     "build"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@modelcontextprotocol/sdk": "^1.9.0",
     "@notionhq/client": "^2.3.0",
     "zod": "^3.24.2"
   },