notion-mcp-server 1.0.1 → 2.4.2

package/build/schema/filter-dsl.js

@@ -0,0 +1,333 @@
+import { z } from "zod";
+// Typed shorthand for Notion `filter` payloads on data source queries.
+// The user writes `{Status: "Done", Priority: {gte: 3}}` and we compile to
+// the verbose Notion JSON. Multi-key clauses are implicit AND; explicit
+// {AND/OR/NOT: ...} blocks compose. Property TYPE is inferred from value
+// shape — pass `__type: "multi_select"` etc. when inference is wrong.
+// ─── Property types — single source of truth ────────────────────────────────
+const PROPERTY_TYPES = [
+    "title",
+    "rich_text",
+    "number",
+    "select",
+    "multi_select",
+    "status",
+    "date",
+    "checkbox",
+    "people",
+    "files",
+    "relation",
+    "url",
+    "email",
+    "phone_number",
+    "created_time",
+    "last_edited_time",
+    "created_by",
+    "last_edited_by",
+    "unique_id",
+];
+// ─── DSL operator surface ───────────────────────────────────────────────────
+const SCALAR = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+const OPERATORS_SCHEMA = z
+    .object({
+    eq: z.union([SCALAR, z.array(SCALAR)]).optional(),
+    ne: z.union([SCALAR, z.array(SCALAR)]).optional(),
+    gt: SCALAR.optional(),
+    gte: SCALAR.optional(),
+    lt: SCALAR.optional(),
+    lte: SCALAR.optional(),
+    contains: z.string().optional(),
+    notContains: z.string().optional(),
+    startsWith: z.string().optional(),
+    endsWith: z.string().optional(),
+    in: z.array(SCALAR).optional(),
+    notIn: z.array(SCALAR).optional(),
+    is_empty: z.boolean().optional(),
+    is_not_empty: z.boolean().optional(),
+    before: z.string().optional(),
+    after: z.string().optional(),
+    on_or_before: z.string().optional(),
+    on_or_after: z.string().optional(),
+    __type: z.enum(PROPERTY_TYPES).optional(),
+})
+    .strict();
+export const WHERE_SCHEMA = z.record(z.string(), z.unknown()).describe("Typed filter DSL. Property names map to scalar values (equals shorthand) or operator objects like {gte:3, contains:'x'}. Top-level AND/OR arrays and NOT compose.");
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}/;
+function isDateLike(v) {
+    return typeof v === "string" && ISO_DATE_RE.test(v);
+}
+// Single place where we narrow unknown → keyed object. Throws so the caller
+// surfaces a helpful where_compile_error rather than silently mis-typing.
+function asObject(value, context) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${context}: expected object, got ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+// ─── Operator maps per property-type family ─────────────────────────────────
+const NUMERIC_OP_MAP = {
+    eq: "equals",
+    ne: "does_not_equal",
+    gt: "greater_than",
+    gte: "greater_than_or_equal_to",
+    lt: "less_than",
+    lte: "less_than_or_equal_to",
+};
+const DATE_OP_MAP = {
+    eq: "equals",
+    ne: "does_not_equal",
+    gt: "after",
+    gte: "on_or_after",
+    lt: "before",
+    lte: "on_or_before",
+    before: "before",
+    after: "after",
+    on_or_before: "on_or_before",
+    on_or_after: "on_or_after",
+};
+const TEXT_OP_MAP = {
+    eq: "equals",
+    ne: "does_not_equal",
+    contains: "contains",
+    notContains: "does_not_contain",
+    startsWith: "starts_with",
+    endsWith: "ends_with",
+};
+const SELECT_OP_MAP = {
+    eq: "equals",
+    ne: "does_not_equal",
+};
+const MULTI_SELECT_OP_MAP = {
+    eq: "contains",
+    ne: "does_not_contain",
+    contains: "contains",
+    notContains: "does_not_contain",
+};
+const EMPTINESS_OPS = new Set(["is_empty", "is_not_empty"]);
+const TYPE_OP_MAP = {
+    number: NUMERIC_OP_MAP,
+    unique_id: NUMERIC_OP_MAP,
+    date: DATE_OP_MAP,
+    created_time: DATE_OP_MAP,
+    last_edited_time: DATE_OP_MAP,
+    title: TEXT_OP_MAP,
+    rich_text: TEXT_OP_MAP,
+    url: TEXT_OP_MAP,
+    email: TEXT_OP_MAP,
+    phone_number: TEXT_OP_MAP,
+    select: SELECT_OP_MAP,
+    status: SELECT_OP_MAP,
+    multi_select: MULTI_SELECT_OP_MAP,
+    relation: MULTI_SELECT_OP_MAP,
+    people: MULTI_SELECT_OP_MAP,
+    files: MULTI_SELECT_OP_MAP,
+    checkbox: SELECT_OP_MAP,
+    created_by: SELECT_OP_MAP,
+    last_edited_by: SELECT_OP_MAP,
+};
+function opMapFor(type) {
+    return TYPE_OP_MAP[type] ?? SELECT_OP_MAP;
+}
+// ─── Type inference ─────────────────────────────────────────────────────────
+const DATE_ONLY_OPS = ["before", "after", "on_or_before", "on_or_after"];
+const TEXT_ONLY_OPS = ["contains", "notContains", "startsWith", "endsWith"];
+function inferTypeFromScalar(v) {
+    if (typeof v === "number")
+        return "number";
+    if (typeof v === "boolean")
+        return "checkbox";
+    return isDateLike(v) ? "date" : "select";
+}
+function inferTypeFromOps(ops) {
+    const hint = ops.__type;
+    if (typeof hint === "string" && PROPERTY_TYPES.includes(hint)) {
+        return hint;
+    }
+    if (DATE_ONLY_OPS.some((k) => k in ops))
+        return "date";
+    if (TEXT_ONLY_OPS.some((k) => k in ops))
+        return "rich_text";
+    const sample = ops.eq ?? ops.ne ?? ops.gt ?? ops.gte ?? ops.lt ?? ops.lte ?? ops.in ?? ops.notIn;
+    if (Array.isArray(sample)) {
+        const first = sample[0];
+        if (typeof first === "number")
+            return "number";
+        if (typeof first === "string" && isDateLike(first))
+            return "date";
+        return "select";
+    }
+    if (typeof sample === "number" || typeof sample === "boolean") {
+        return inferTypeFromScalar(sample);
+    }
+    if (typeof sample === "string")
+        return inferTypeFromScalar(sample);
+    // is_empty / is_not_empty alone → rich_text default (works on most types)
+    return "rich_text";
+}
+// ─── Leaf compilation ───────────────────────────────────────────────────────
+function buildLeaf(propertyName, type, condition) {
+    return { property: propertyName, [type]: condition };
+}
+function compilePropertyClause(propertyName, value) {
+    // Bare scalar shorthand → equals
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const type = inferTypeFromScalar(value);
+        const opMap = opMapFor(type);
+        return buildLeaf(propertyName, type, { [opMap.eq]: value });
+    }
+    if (value === null) {
+        return buildLeaf(propertyName, "rich_text", { is_empty: true });
+    }
+    const ops = asObject(value, `filter value for property "${propertyName}"`);
+    const type = inferTypeFromOps(ops);
+    const opMap = opMapFor(type);
+    // {in: [...]} → OR of equals on the same property
+    if (Array.isArray(ops.in)) {
+        if (ops.in.length === 0) {
+            throw new Error(`"in" on property "${propertyName}" must be non-empty`);
+        }
+        return {
+            or: ops.in.map((v) => buildLeaf(propertyName, type, { [opMap.eq]: v })),
+        };
+    }
+    if (Array.isArray(ops.notIn)) {
+        if (ops.notIn.length === 0) {
+            throw new Error(`"notIn" on property "${propertyName}" must be non-empty`);
+        }
+        return {
+            and: ops.notIn.map((v) => buildLeaf(propertyName, type, { [opMap.ne]: v })),
+        };
+    }
+    const conditions = [];
+    for (const [opKey, opVal] of Object.entries(ops)) {
+        if (opKey === "__type" || opVal === undefined)
+            continue;
+        if (EMPTINESS_OPS.has(opKey)) {
+            if (opVal !== true)
+                continue;
+            conditions.push([opKey, true]);
+            continue;
+        }
+        const notionOp = opMap[opKey];
+        if (!notionOp) {
+            throw new Error(`Unsupported operator "${opKey}" on property "${propertyName}" (inferred type: ${type}). Use __type to override.`);
+        }
+        conditions.push([notionOp, opVal]);
+    }
+    if (conditions.length === 0) {
+        throw new Error(`No usable operators on property "${propertyName}"`);
+    }
+    if (conditions.length === 1) {
+        const [notionOp, opVal] = conditions[0];
+        return buildLeaf(propertyName, type, { [notionOp]: opVal });
+    }
+    return {
+        and: conditions.map(([k, v]) => buildLeaf(propertyName, type, { [k]: v })),
+    };
+}
+// ─── Negation (De Morgan + per-leaf inversion) ──────────────────────────────
+const INVERSE_LEAF_OP = {
+    equals: "does_not_equal",
+    does_not_equal: "equals",
+    contains: "does_not_contain",
+    does_not_contain: "contains",
+    is_empty: "is_not_empty",
+    is_not_empty: "is_empty",
+    greater_than: "less_than_or_equal_to",
+    less_than: "greater_than_or_equal_to",
+    greater_than_or_equal_to: "less_than",
+    less_than_or_equal_to: "greater_than",
+    before: "on_or_after",
+    after: "on_or_before",
+    on_or_before: "after",
+    on_or_after: "before",
+};
+function negateChildren(arr) {
+    return arr.map((f, i) => negate(asObject(f, `NOT child[${i}]`)));
+}
+function negate(filter) {
+    if (Array.isArray(filter.and))
+        return { or: negateChildren(filter.and) };
+    if (Array.isArray(filter.or))
+        return { and: negateChildren(filter.or) };
+    if (typeof filter.property !== "string") {
+        throw new Error(`Cannot negate filter: unsupported shape ${JSON.stringify(filter)}`);
+    }
+    const typeKeys = Object.keys(filter).filter((k) => k !== "property");
+    if (typeKeys.length !== 1) {
+        throw new Error("NOT requires a single typed leaf or a logical compound");
+    }
+    const typeKey = typeKeys[0];
+    const inner = asObject(filter[typeKey], `NOT leaf "${filter.property}"`);
+    const innerKeys = Object.keys(inner);
+    if (innerKeys.length !== 1) {
+        throw new Error("NOT cannot negate a leaf with multiple operators; rewrite as AND/OR first");
+    }
+    const op = innerKeys[0];
+    const inv = INVERSE_LEAF_OP[op];
+    if (!inv) {
+        throw new Error(`Operator "${op}" has no inverse; rewrite without NOT`);
+    }
+    return { property: filter.property, [typeKey]: { [inv]: inner[op] } };
+}
+// ─── Top-level recursion ────────────────────────────────────────────────────
+// Boolean combinator keywords are case-insensitive. Lowercase is the
+// canonical form (matches Notion's own filter JSON), but uppercase is
+// accepted so callers who think of AND/OR/NOT as SQL-style keywords
+// don't trip on case. A column literally named "and"/"AND" must be
+// disambiguated with __type via an operator object — collision is
+// documented in the resource.
+const AND_KEYS = new Set(["and", "AND"]);
+const OR_KEYS = new Set(["or", "OR"]);
+const NOT_KEYS = new Set(["not", "NOT"]);
+function compileCombinator(value, keyword, wrapKey) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${keyword} must be an array of where clauses`);
+    }
+    const inner = [];
+    for (const child of value) {
+        const compiled = compileWhere(child);
+        if (compiled)
+            inner.push(compiled);
+    }
+    if (inner.length === 0)
+        return undefined;
+    if (inner.length === 1)
+        return inner[0];
+    return { [wrapKey]: inner };
+}
+export function compileWhere(where) {
+    if (where === undefined || where === null)
+        return undefined;
+    const obj = asObject(where, "where clause");
+    const entries = Object.entries(obj);
+    if (entries.length === 0)
+        return undefined;
+    const parts = [];
+    for (const [key, value] of entries) {
+        if (AND_KEYS.has(key)) {
+            const compiled = compileCombinator(value, key, "and");
+            if (compiled)
+                parts.push(compiled);
+            continue;
+        }
+        if (OR_KEYS.has(key)) {
+            const compiled = compileCombinator(value, key, "or");
+            if (compiled)
+                parts.push(compiled);
+            continue;
+        }
+        if (NOT_KEYS.has(key)) {
+            const inner = compileWhere(value);
+            if (inner)
+                parts.push(negate(inner));
+            continue;
+        }
+        parts.push(compilePropertyClause(key, value));
+    }
+    if (parts.length === 0)
+        return undefined;
+    if (parts.length === 1)
+        return parts[0];
+    return { and: parts };
+}

package/build/schema/icon.js

@@ -3,7 +3,7 @@ export const ICON_SCHEMA = z.object({
     emoji: z
         .string()
         .refine((value) => /(\p{Emoji}\uFE0F|\p{Emoji_Presentation})/gu.test(value), {
-        message: "Invalid emoji",
+        error: "Invalid emoji",
     })
         .transform((value) => value),
     type: z.literal("emoji"),

package/build/schema/page-properties.js

@@ -10,13 +10,13 @@ export const DATE_PROPERTY_VALUE_SCHEMA = z.object({
     }),
 });
 export const EMAIL_PROPERTY_VALUE_SCHEMA = z.object({
-    email: z.string().email(),
+    email: z.email(),
 });
 export const FILES_PROPERTY_VALUE_SCHEMA = z.object({
     files: z.array(z.object({
         name: z.string(),
         external: z.object({
-            url: z.string().url(),
+            url: z.url({ protocol: /^https?$/ }),
         }),
     })),
 });
@@ -56,5 +56,19 @@ export const TITLE_PROPERTY_VALUE_SCHEMA = z.object({
     title: z.array(TEXT_RICH_TEXT_ITEM_REQUEST_SCHEMA),
 });
 export const URL_PROPERTY_VALUE_SCHEMA = z.object({
-    url: z.string().url(),
+    url: z.url({ protocol: /^https?$/ }),
+});
+export const VERIFICATION_PROPERTY_VALUE_SCHEMA = z.object({
+    verification: z
+        .object({
+        state: z.enum(["verified", "unverified", "expired"]),
+        verified_by: z
+            .object({ id: z.string(), object: z.literal("user").optional() })
+            .optional(),
+        date: z
+            .object({ start: z.string(), end: z.string().nullable().optional() })
+            .nullable()
+            .optional(),
+    })
+        .describe("Verification property value"),
 });

package/build/schema/page.js

@@ -1,18 +1,4 @@
 import { z } from "zod";
-import { getRootPageId } from "../services/notion.js";
-import { ICON_SCHEMA } from "./icon.js";
-import { TEXT_BLOCK_REQUEST_SCHEMA } from "./blocks.js";
-import { preprocessJson } from "./preprocess.js";
-import { TEXT_CONTENT_REQUEST_SCHEMA } from "./rich-text.js";
-import { FILE_SCHEMA } from "./file.js";
-import { CHECKBOX_PROPERTY_VALUE_SCHEMA, DATE_PROPERTY_VALUE_SCHEMA, EMAIL_PROPERTY_VALUE_SCHEMA, FILES_PROPERTY_VALUE_SCHEMA, NUMBER_PROPERTY_VALUE_SCHEMA, PEOPLE_PROPERTY_VALUE_SCHEMA, PHONE_NUMBER_PROPERTY_VALUE_SCHEMA, RELATION_PROPERTY_VALUE_SCHEMA, RICH_TEXT_PROPERTY_VALUE_SCHEMA, SELECT_PROPERTY_VALUE_SCHEMA, STATUS_PROPERTY_VALUE_SCHEMA, } from "./page-properties.js";
-export const TITLE_PROPERTY_SCHEMA = z.object({
-    title: z
-        .array(z.object({
-        text: TEXT_CONTENT_REQUEST_SCHEMA.describe("Text content for title segment"),
-    }))
-        .describe("Array of text segments that make up the title"),
-});
 export const PARENT_SCHEMA = z.preprocess((val) => (typeof val === "string" ? JSON.parse(val) : val), z.union([
     z.object({
         type: z.literal("page_id").describe("Parent type for page"),
@@ -22,115 +8,16 @@ export const PARENT_SCHEMA = z.preprocess((val) => (typeof val === "string" ? JS
         type: z.literal("database_id").describe("Parent type for database"),
         database_id: z.string().describe("ID of the parent database"),
     }),
+    z.object({
+        type: z.literal("data_source_id").describe("Parent type for data source (preferred for create_page targeting a database)"),
+        data_source_id: z.string().describe("ID of the parent data source"),
+    }),
+    z.object({
+        type: z.literal("workspace").describe("Workspace-level parent (admin contexts only)"),
+        workspace: z.literal(true),
+    }),
+    z.object({
+        type: z.literal("block_id").describe("Parent type for nested block"),
+        block_id: z.string(),
+    }),
 ]));
-export const CREATE_PAGE_SCHEMA = {
-    parent: PARENT_SCHEMA.optional()
-        .default({
-        type: "page_id",
-        page_id: getRootPageId(),
-    })
-        .describe("Optional parent - if not provided, will use NOTION_PAGE_ID as parent page"),
-    properties: z
-        .record(z.string().describe("Property name"), z.union([
-        TITLE_PROPERTY_SCHEMA,
-        CHECKBOX_PROPERTY_VALUE_SCHEMA,
-        EMAIL_PROPERTY_VALUE_SCHEMA,
-        STATUS_PROPERTY_VALUE_SCHEMA,
-        FILES_PROPERTY_VALUE_SCHEMA,
-        DATE_PROPERTY_VALUE_SCHEMA,
-        PEOPLE_PROPERTY_VALUE_SCHEMA,
-        PHONE_NUMBER_PROPERTY_VALUE_SCHEMA,
-        RELATION_PROPERTY_VALUE_SCHEMA,
-        RICH_TEXT_PROPERTY_VALUE_SCHEMA,
-        SELECT_PROPERTY_VALUE_SCHEMA,
-        NUMBER_PROPERTY_VALUE_SCHEMA,
-    ]))
-        .describe("Properties of the page"),
-    children: z
-        .array(TEXT_BLOCK_REQUEST_SCHEMA)
-        .optional()
-        .describe("Optional array of paragraph blocks to add as page content"),
-    icon: z.preprocess(preprocessJson, ICON_SCHEMA.nullable().optional().describe("Optional icon for the page")),
-    cover: z.preprocess(preprocessJson, FILE_SCHEMA.nullable()
-        .optional()
-        .describe("Optional cover image for the page")),
-};
-export const ARCHIVE_PAGE_SCHEMA = {
-    pageId: z.string().describe("The ID of the page to archive"),
-};
-export const RESTORE_PAGE_SCHEMA = {
-    pageId: z.string().describe("The ID of the page to restore"),
-};
-export const UPDATE_PAGE_PROPERTIES_SCHEMA = {
-    pageId: z.string().describe("The ID of the page to restore"),
-    properties: z
-        .record(z.string().describe("Property name"), z.union([
-        TITLE_PROPERTY_SCHEMA,
-        CHECKBOX_PROPERTY_VALUE_SCHEMA,
-        EMAIL_PROPERTY_VALUE_SCHEMA,
-        STATUS_PROPERTY_VALUE_SCHEMA,
-        FILES_PROPERTY_VALUE_SCHEMA,
-        DATE_PROPERTY_VALUE_SCHEMA,
-        PEOPLE_PROPERTY_VALUE_SCHEMA,
-        PHONE_NUMBER_PROPERTY_VALUE_SCHEMA,
-        RELATION_PROPERTY_VALUE_SCHEMA,
-        RICH_TEXT_PROPERTY_VALUE_SCHEMA,
-        SELECT_PROPERTY_VALUE_SCHEMA,
-        NUMBER_PROPERTY_VALUE_SCHEMA,
-    ]))
-        .describe("Properties of the page"),
-};
-export const SEARCH_PAGES_SCHEMA = {
-    query: z.string().optional().describe("Search query for filtering by title"),
-    sort: z
-        .object({
-        direction: z.enum(["ascending", "descending"]),
-        timestamp: z.literal("last_edited_time"),
-    })
-        .optional()
-        .describe("Sort order for results"),
-    start_cursor: z.string().optional().describe("Cursor for pagination"),
-    page_size: z
-        .number()
-        .min(1)
-        .max(100)
-        .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/refs.js

@@ -0,0 +1,16 @@
+import { RICH_TEXT_ITEM_REQUEST_SCHEMA } from "./rich-text.js";
+import { PARENT_SCHEMA } from "./page.js";
+import { ICON_SCHEMA } from "./icon.js";
+import { FILE_SCHEMA } from "./file.js";
+import { registerSharedRef } from "./emit.js";
+/**
+ * Canonical sub-schemas registered for $defs hoisting in emitted JSON Schemas.
+ * When any operation's input mentions one of these structurally, the emitter
+ * replaces the inlined copy with a $ref. This is where most schema-size wins come from.
+ */
+export function registerSharedSubSchemas() {
+    registerSharedRef("rich_text_item", RICH_TEXT_ITEM_REQUEST_SCHEMA);
+    registerSharedRef("parent", PARENT_SCHEMA);
+    registerSharedRef("icon", ICON_SCHEMA);
+    registerSharedRef("file", FILE_SCHEMA);
+}

package/build/schema/rich-text.js

@@ -14,7 +14,7 @@ export const TEXT_CONTENT_REQUEST_SCHEMA = z
     content: z.string().describe("The actual text content"),
     link: z
         .object({
-        url: z.string().url().describe("URL for the link"),
+        url: z.url({ protocol: /^https?$/ }).describe("URL for the link"),
     })
         .optional()
         .nullable()

package/build/server/index.js

@@ -1,16 +1,19 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CONFIG } from "../config/index.js";
+import { getClient } from "../services/notion.js";
 export const server = new McpServer({
     name: CONFIG.serverName,
+    title: CONFIG.serverTitle,
     version: CONFIG.serverVersion,
+    websiteUrl: CONFIG.serverUrl,
 }, {
     capabilities: {
-        resources: {},
         tools: {},
+        prompts: {},
     },
     instructions: `
-      MCP server for the Notion.
+      MCP server for Notion.
       It is used to create, update and delete Notion entities.
     `,
 });
@@ -18,7 +21,17 @@ export async function startServer() {
     try {
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.log(`${CONFIG.serverName} v${CONFIG.serverVersion} running on stdio`);
+        console.error(`${CONFIG.serverName} v${CONFIG.serverVersion} running on stdio`);
+        getClient()
+            .then((c) => c.users.me({}))
+            .then((me) => {
+            const who = "name" in me && me.name ? me.name : me.id;
+            console.error(`Notion auth OK — connected as ${who} (NOTION_TOKEN)`);
+        })
+            .catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`Notion auth check failed (server still running): ${msg}`);
+        });
     }
     catch (error) {
         console.error("Server initialization error:", error instanceof Error ? error.message : String(error));

package/build/services/auth.js

@@ -0,0 +1,19 @@
+// src/services/auth.ts
+export class AuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthError";
+    }
+}
+export class EnvAuthProvider {
+    async getToken() {
+        const t = process.env.NOTION_TOKEN;
+        if (!t) {
+            throw new AuthError("Notion auth token is not configured. Set the NOTION_TOKEN environment variable in your MCP client config. To get a token, open Notion → Settings → My Settings → Personal Access Tokens → Generate (recommended), or Settings → Connections → Develop or manage integrations → New integration.");
+        }
+        return t;
+    }
+}
+// Singleton — single-user assumption. v3 multi-user OAuth would require
+// per-request provider dispatch (different pattern; out of scope for v2).
+export const authProvider = new EnvAuthProvider();

package/build/services/notion.js

@@ -1,20 +1,17 @@
 import { Client } from "@notionhq/client";
-export function getApiToken() {
-    const token = process.env.NOTION_TOKEN;
-    if (!token) {
-        console.error("Error: NOTION_TOKEN environment variable is required");
-        process.exit(1);
+import { authProvider } from "./auth.js";
+let cachedClient = null;
+let cachedToken = null;
+export async function getClient() {
+    const token = await authProvider.getToken();
+    if (token !== cachedToken || cachedClient === null) {
+        const fresh = new Client({
+            auth: token,
+            notionVersion: "2025-09-03",
+        });
+        cachedClient = fresh;
+        cachedToken = token;
+        return fresh;
     }
-    return token;
+    return cachedClient;
 }
-export function getRootPageId() {
-    const pageId = process.env.NOTION_PAGE_ID;
-    if (!pageId) {
-        console.error("Error: NOTION_PAGE_ID environment variable is required");
-        process.exit(1);
-    }
-    return pageId;
-}
-export const notion = new Client({
-    auth: process.env.NOTION_TOKEN,
-});