@striderlabs/mcp-notion 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+var API_KEY = process.env.NOTION_API_KEY;
+var BASE_URL = "https://api.notion.com/v1";
+var NOTION_VERSION = "2022-06-28";
+async function notionRequest(method, path, body) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Notion-Version": NOTION_VERSION
+  };
+  if (API_KEY) {
+    headers["Authorization"] = `Bearer ${API_KEY}`;
+  }
+  const res = await fetch(`${BASE_URL}${path}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Notion API error ${res.status}: ${JSON.stringify(data)}`);
+  }
+  return data;
+}
+var server = new Server(
+  { name: "mcp-notion", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "search_pages",
+      description: "Search Notion pages and databases",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          page_size: { type: "number", description: "Number of results (max 100)" }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "get_page",
+      description: "Get a Notion page by ID",
+      inputSchema: {
+        type: "object",
+        properties: {
+          page_id: { type: "string", description: "The page ID" }
+        },
+        required: ["page_id"]
+      }
+    },
+    {
+      name: "create_page",
+      description: "Create a new Notion page",
+      inputSchema: {
+        type: "object",
+        properties: {
+          parent_type: { type: "string", enum: ["database_id", "page_id"], description: "Parent type" },
+          parent_id: { type: "string", description: "Parent ID" },
+          title: { type: "string", description: "Page title" },
+          properties: { type: "object", description: "Additional properties" }
+        },
+        required: ["parent_type", "parent_id", "title"]
+      }
+    },
+    {
+      name: "update_page",
+      description: "Update a Notion page",
+      inputSchema: {
+        type: "object",
+        properties: {
+          page_id: { type: "string", description: "The page ID" },
+          properties: { type: "object", description: "Properties to update" }
+        },
+        required: ["page_id", "properties"]
+      }
+    },
+    {
+      name: "query_database",
+      description: "Query a Notion database",
+      inputSchema: {
+        type: "object",
+        properties: {
+          database_id: { type: "string", description: "The database ID" },
+          filter: { type: "object", description: "Filter conditions" },
+          sorts: { type: "array", description: "Sort conditions" },
+          page_size: { type: "number", description: "Number of results" }
+        },
+        required: ["database_id"]
+      }
+    },
+    {
+      name: "create_database_entry",
+      description: "Create an entry in a Notion database",
+      inputSchema: {
+        type: "object",
+        properties: {
+          database_id: { type: "string", description: "The database ID" },
+          properties: { type: "object", description: "Entry properties" }
+        },
+        required: ["database_id", "properties"]
+      }
+    },
+    {
+      name: "get_block_children",
+      description: "Get children blocks of a Notion block",
+      inputSchema: {
+        type: "object",
+        properties: {
+          block_id: { type: "string", description: "The block ID" },
+          page_size: { type: "number", description: "Number of results" }
+        },
+        required: ["block_id"]
+      }
+    },
+    {
+      name: "append_blocks",
+      description: "Append blocks to a Notion block",
+      inputSchema: {
+        type: "object",
+        properties: {
+          block_id: { type: "string", description: "The block ID" },
+          children: { type: "array", description: "Array of block objects to append" }
+        },
+        required: ["block_id", "children"]
+      }
+    }
+  ]
+}));
+var SearchPagesSchema = z.object({
+  query: z.string(),
+  page_size: z.number().optional()
+});
+var GetPageSchema = z.object({ page_id: z.string() });
+var CreatePageSchema = z.object({
+  parent_type: z.enum(["database_id", "page_id"]),
+  parent_id: z.string(),
+  title: z.string(),
+  properties: z.record(z.string(), z.unknown()).optional()
+});
+var UpdatePageSchema = z.object({
+  page_id: z.string(),
+  properties: z.record(z.string(), z.unknown())
+});
+var QueryDatabaseSchema = z.object({
+  database_id: z.string(),
+  filter: z.record(z.string(), z.unknown()).optional(),
+  sorts: z.array(z.unknown()).optional(),
+  page_size: z.number().optional()
+});
+var CreateDatabaseEntrySchema = z.object({
+  database_id: z.string(),
+  properties: z.record(z.string(), z.unknown())
+});
+var GetBlockChildrenSchema = z.object({
+  block_id: z.string(),
+  page_size: z.number().optional()
+});
+var AppendBlocksSchema = z.object({
+  block_id: z.string(),
+  children: z.array(z.unknown())
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "search_pages": {
+        const { query, page_size } = SearchPagesSchema.parse(args);
+        const result = await notionRequest("POST", "/search", {
+          query,
+          page_size: page_size ?? 10
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_page": {
+        const { page_id } = GetPageSchema.parse(args);
+        const result = await notionRequest("GET", `/pages/${page_id}`);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "create_page": {
+        const { parent_type, parent_id, title, properties } = CreatePageSchema.parse(args);
+        const body = {
+          parent: { [parent_type]: parent_id },
+          properties: {
+            title: { title: [{ text: { content: title } }] },
+            ...properties
+          }
+        };
+        const result = await notionRequest("POST", "/pages", body);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "update_page": {
+        const { page_id, properties } = UpdatePageSchema.parse(args);
+        const result = await notionRequest("PATCH", `/pages/${page_id}`, { properties });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "query_database": {
+        const { database_id, filter, sorts, page_size } = QueryDatabaseSchema.parse(args);
+        const body = {};
+        if (filter) body.filter = filter;
+        if (sorts) body.sorts = sorts;
+        if (page_size) body.page_size = page_size;
+        const result = await notionRequest("POST", `/databases/${database_id}/query`, body);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "create_database_entry": {
+        const { database_id, properties } = CreateDatabaseEntrySchema.parse(args);
+        const result = await notionRequest("POST", "/pages", {
+          parent: { database_id },
+          properties
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_block_children": {
+        const { block_id, page_size } = GetBlockChildrenSchema.parse(args);
+        const qs = page_size ? `?page_size=${page_size}` : "";
+        const result = await notionRequest("GET", `/blocks/${block_id}/children${qs}`);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "append_blocks": {
+        const { block_id, children } = AppendBlocksSchema.parse(args);
+        const result = await notionRequest("PATCH", `/blocks/${block_id}/children`, { children });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@striderlabs/mcp-notion",
+  "version": "1.0.0",
+  "description": "MCP connector for Notion API",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-notion": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "tsup": "latest",
+    "typescript": "latest",
+    "@types/node": "latest"
+  }
+}