@alfe.ai/notion-mcp 0.3.0

package/dist/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+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 { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { resolveConfig } from "@alfe.ai/config";
+import { AgentApiClient } from "@alfe.ai/agent-api-client";
+//#region src/server.ts
+/**
+* Notion MCP Proxy Server (Pattern A multi-account)
+*
+* A thin proxy that fans out to one official `@notionhq/notion-mcp-server`
+* child process per connected Notion workspace. Every credential-touching
+* tool requires the LLM to pass a `workspaceId` selector arg; the proxy
+* strips that arg, dispatches to the right child, and returns the result.
+*
+* Pattern A locked in PR 7.2 of channels-and-credential-driven-
+* integrations. See `packages/mcp-bundler/DEVELOPING.md` for the
+* contract; `services/connect/DEVELOPING.md` for the provider table.
+*
+* Architecture:
+*   OpenClaw ←(stdio)→ this proxy ←(stdio fan-out)→ N × @notionhq/notion-mcp-server
+*
+* Notion access tokens persist until the user revokes the integration,
+* so there's no token-refresh path.
+*
+* Uses the low-level Server class (not McpServer) because child tools
+* return JSON Schema objects — McpServer.registerTool requires Zod.
+*/
+const workspaces = /* @__PURE__ */ new Map();
+/**
+* Full snapshot of every Notion connection returned by getNotionAccounts(),
+* including ones we couldn't spawn a child for (e.g. missing access token).
+* `notion_list_accounts` returns this so the LLM can surface partial-failure
+* connections instead of silently dropping them.
+*/
+const allAccountsSnapshot = [];
+/** Cached, selector-injected tool list returned to OpenClaw. */
+let cachedTools = [];
+function log(msg) {
+	process.stderr.write(`[notion-mcp-proxy] ${msg}\n`);
+}
+function resolveWorkspace(workspaceId) {
+	if (!workspaceId) throw new Error("Missing required workspaceId argument. Call notion_list_accounts to see the connected Notion workspaces and pass the workspaceId you want to target.");
+	const ws = workspaces.get(workspaceId);
+	if (!ws) {
+		const known = allAccountsSnapshot.find((s) => s.workspaceId === workspaceId);
+		if (known && !known.connected) throw new Error(`workspaceId ${workspaceId} is connected on this agent but the proxy could not initialise a child server for it (reason: ${known.reason ?? "unknown"}). Ask the user to reconnect this Notion workspace from the dashboard.`);
+		throw new Error(`Unknown workspaceId: ${workspaceId}. Call notion_list_accounts to see the connected Notion workspaces on this agent.`);
+	}
+	return ws;
+}
+async function spawnChild(accessToken) {
+	const transport = new StdioClientTransport({
+		command: "npx",
+		args: ["-y", "@notionhq/notion-mcp-server"],
+		env: {
+			...process.env,
+			NOTION_TOKEN: accessToken
+		}
+	});
+	const client = new Client({
+		name: "notion-mcp-proxy",
+		version: "2.0.0"
+	});
+	await client.connect(transport);
+	return client;
+}
+async function killAllChildren() {
+	for (const ws of workspaces.values()) try {
+		await ws.client.close();
+	} catch {}
+	workspaces.clear();
+}
+/**
+* Take a tool descriptor from the child Notion MCP server and inject a
+* required `workspaceId` string property into its inputSchema. The proxy
+* strips this arg before forwarding the call.
+*/
+function injectWorkspaceSelector(tool) {
+	const original = tool.inputSchema ?? {};
+	const originalProperties = original.properties ?? {};
+	const originalRequired = Array.isArray(original.required) ? original.required : [];
+	const injectedProperties = {
+		...originalProperties,
+		workspaceId: {
+			type: "string",
+			description: "Notion workspaceId — use the value from notion_list_accounts to pick which connected workspace this call should target."
+		}
+	};
+	const injectedRequired = originalRequired.includes("workspaceId") ? originalRequired : ["workspaceId", ...originalRequired];
+	return {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: {
+			...original,
+			type: original.type ?? "object",
+			properties: injectedProperties,
+			required: injectedRequired
+		}
+	};
+}
+async function main() {
+	const config = resolveConfig();
+	const { accounts } = await new AgentApiClient({
+		apiKey: config.apiKey,
+		apiUrl: config.apiUrl
+	}).getNotionAccounts();
+	if (accounts.length === 0) log("No Notion workspaces connected — proxy will start with notion_list_accounts and notion_check_connection only");
+	for (const acct of accounts) {
+		if (!acct.accessToken) {
+			log(`Skipping workspace ${acct.workspaceId} — no access token`);
+			allAccountsSnapshot.push({
+				workspaceId: acct.workspaceId,
+				workspaceName: acct.workspaceName,
+				connectedAt: acct.connectedAt,
+				connected: false,
+				reason: "missing_access_token"
+			});
+			continue;
+		}
+		if (workspaces.has(acct.workspaceId)) {
+			log(`Duplicate workspaceId ${acct.workspaceId} returned by getNotionAccounts() — keeping the first cached child`);
+			continue;
+		}
+		try {
+			const client = await spawnChild(acct.accessToken);
+			workspaces.set(acct.workspaceId, {
+				workspaceId: acct.workspaceId,
+				workspaceName: acct.workspaceName,
+				accessToken: acct.accessToken,
+				client
+			});
+			allAccountsSnapshot.push({
+				workspaceId: acct.workspaceId,
+				workspaceName: acct.workspaceName,
+				connectedAt: acct.connectedAt,
+				connected: true
+			});
+			log(`Spawned child server for workspace ${acct.workspaceId} (${acct.workspaceName || "unnamed"})`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			log(`Failed to spawn child for workspace ${acct.workspaceId}: ${message}`);
+			allAccountsSnapshot.push({
+				workspaceId: acct.workspaceId,
+				workspaceName: acct.workspaceName,
+				connectedAt: acct.connectedAt,
+				connected: false,
+				reason: `spawn_failed: ${message}`
+			});
+		}
+	}
+	const firstWorkspace = workspaces.values().next().value;
+	if (firstWorkspace) {
+		const { tools } = await firstWorkspace.client.listTools();
+		cachedTools = tools.map(injectWorkspaceSelector);
+		log(`Child MCP server provides ${String(cachedTools.length)} tools (selector injected)`);
+	} else {
+		cachedTools = [];
+		log("No child server available — only notion_list_accounts and notion_check_connection will be exposed");
+	}
+	cachedTools.push({
+		name: "notion_list_accounts",
+		description: "List the Notion workspaces the agent has connected. Returns one entry per OAuth connection — use the returned workspaceId values as the `workspaceId` selector arg on every other Notion tool.",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	});
+	cachedTools.push({
+		name: "notion_check_connection",
+		description: "Verify the Notion OAuth2 connection for a specific connected workspace is still valid. Use this if Notion API calls are failing with authentication errors.",
+		inputSchema: {
+			type: "object",
+			properties: { workspaceId: {
+				type: "string",
+				description: "Notion workspaceId — use the value from notion_list_accounts."
+			} },
+			required: ["workspaceId"]
+		}
+	});
+	const proxy = new Server({
+		name: "notion-mcp-proxy",
+		version: "2.0.0"
+	}, { capabilities: { tools: {} } });
+	proxy.setRequestHandler(ListToolsRequestSchema, () => ({ tools: cachedTools }));
+	proxy.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		const argMap = args ?? {};
+		if (name === "notion_list_accounts") return { content: [{
+			type: "text",
+			text: JSON.stringify({ workspaces: allAccountsSnapshot }, null, 2)
+		}] };
+		if (name === "notion_check_connection") try {
+			const ws = resolveWorkspace(typeof argMap.workspaceId === "string" ? argMap.workspaceId : void 0);
+			const response = await fetch("https://api.notion.com/v1/users/me", { headers: {
+				Authorization: `Bearer ${ws.accessToken}`,
+				"Notion-Version": "2022-06-28"
+			} });
+			if (!response.ok) return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						workspaceId: ws.workspaceId,
+						connected: false,
+						status: response.status,
+						error: "Token may have been revoked. Ask the user to reconnect this Notion workspace from the dashboard."
+					})
+				}],
+				isError: true
+			};
+			const user = await response.json();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					workspaceId: ws.workspaceId,
+					connected: true,
+					user
+				})
+			}] };
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+				}],
+				isError: true
+			};
+		}
+		let ws;
+		try {
+			ws = resolveWorkspace(typeof argMap.workspaceId === "string" ? argMap.workspaceId : void 0);
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+				}],
+				isError: true
+			};
+		}
+		const { workspaceId: _ignored, ...forwarded } = argMap;
+		try {
+			return await ws.client.callTool({
+				name,
+				arguments: forwarded
+			});
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						workspaceId: ws.workspaceId,
+						tool: name,
+						error: err instanceof Error ? err.message : String(err)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	const transport = new StdioServerTransport();
+	await proxy.connect(transport);
+	log(`Proxy running with ${String(workspaces.size)} connected workspace(s) and Pattern A selector enforcement`);
+}
+for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+	killAllChildren().then(() => {
+		process.exit(0);
+	});
+});
+main().catch((err) => {
+	log(`Fatal: ${err instanceof Error ? err.message : String(err)}`);
+	killAllChildren().finally(() => {
+		process.exit(1);
+	});
+});
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@alfe.ai/notion-mcp",
+  "version": "0.3.0",
+  "description": "Notion MCP proxy server — bridges the official @notionhq/notion-mcp-server with Alfe OAuth credentials",
+  "type": "module",
+  "main": "./dist/server.js",
+  "bin": {
+    "notion-mcp-proxy": "./dist/server.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": ">=1.24.0",
+    "@notionhq/notion-mcp-server": "^2.2.1",
+    "@alfe.ai/config": "0.1.0",
+    "@alfe.ai/agent-api-client": "0.3.0"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}