affine-mcp-server 1.2.2 → 1.4.0

package/dist/tools/notifications.js

@@ -2,30 +2,41 @@ import { z } from "zod";
 import { text } from "../util/mcp.js";
 export function registerNotificationTools(server, gql) {
     // LIST NOTIFICATIONS
-    const listNotificationsHandler = async ({ first = 20, unreadOnly = false }) => {
+    const listNotificationsHandler = async ({ first = 20, offset, after, unreadOnly = false }) => {
         try {
             const query = `
-        query GetNotifications($first: Int!) {
+        query GetNotifications($pagination: PaginationInput!) {
           currentUser {
-            notifications(first: $first) {
-              nodes {
-                id
-                type
-                title
-                body
-                read
-                createdAt
+            notifications(pagination: $pagination) {
+              edges {
+                cursor
+                node {
+                  id
+                  type
+                  body
+                  read
+                  level
+                  createdAt
+                  updatedAt
+                }
               }
               totalCount
               pageInfo {
                 hasNextPage
+                endCursor
               }
             }
           }
         }
       `;
-            const data = await gql.request(query, { first });
-            let notifications = data.currentUser?.notifications?.nodes || [];
+            const data = await gql.request(query, {
+                pagination: {
+                    first,
+                    offset,
+                    after
+                }
+            });
+            let notifications = (data.currentUser?.notifications?.edges || []).map((edge) => edge.node);
             if (unreadOnly) {
                 notifications = notifications.filter((n) => !n.read);
             }
@@ -35,51 +46,16 @@ export function registerNotificationTools(server, gql) {
             return text({ error: error.message });
         }
     };
-    server.registerTool("affine_list_notifications", {
-        title: "List Notifications",
-        description: "Get user notifications.",
-        inputSchema: {
-            first: z.number().optional().describe("Number of notifications to fetch"),
-            unreadOnly: z.boolean().optional().describe("Show only unread notifications")
-        }
-    }, listNotificationsHandler);
     server.registerTool("list_notifications", {
         title: "List Notifications",
         description: "Get user notifications.",
         inputSchema: {
             first: z.number().optional().describe("Number of notifications to fetch"),
+            offset: z.number().optional().describe("Offset for pagination"),
+            after: z.string().optional().describe("Cursor for pagination"),
             unreadOnly: z.boolean().optional().describe("Show only unread notifications")
         }
     }, listNotificationsHandler);
-    // MARK NOTIFICATION AS READ
-    const readNotificationHandler = async ({ id }) => {
-        try {
-            const mutation = `
-        mutation ReadNotification($id: String!) {
-          readNotification(id: $id)
-        }
-      `;
-            const data = await gql.request(mutation, { id });
-            return text({ success: data.readNotification, notificationId: id });
-        }
-        catch (error) {
-            return text({ error: error.message });
-        }
-    };
-    server.registerTool("affine_read_notification", {
-        title: "Mark Notification Read",
-        description: "Mark a notification as read.",
-        inputSchema: {
-            id: z.string().describe("Notification ID")
-        }
-    }, readNotificationHandler);
-    server.registerTool("read_notification", {
-        title: "Mark Notification Read",
-        description: "Mark a notification as read.",
-        inputSchema: {
-            id: z.string().describe("Notification ID")
-        }
-    }, readNotificationHandler);
     // MARK ALL NOTIFICATIONS READ
     const readAllNotificationsHandler = async () => {
         try {
@@ -95,11 +71,6 @@ export function registerNotificationTools(server, gql) {
             return text({ error: error.message });
         }
     };
-    server.registerTool("affine_read_all_notifications", {
-        title: "Mark All Notifications Read",
-        description: "Mark all notifications as read.",
-        inputSchema: {}
-    }, readAllNotificationsHandler);
     server.registerTool("read_all_notifications", {
         title: "Mark All Notifications Read",
         description: "Mark all notifications as read.",

package/dist/tools/user.js

@@ -5,11 +5,6 @@ export function registerUserTools(server, gql) {
         const data = await gql.request(query);
         return text(data.currentUser);
     };
-    server.registerTool("affine_current_user", {
-        title: "Current User",
-        description: "Get current signed-in user.",
-        inputSchema: {}
-    }, currentUserHandler);
     server.registerTool("current_user", {
         title: "Current User",
         description: "Get current signed-in user.",

package/dist/tools/userCRUD.js

@@ -26,14 +26,6 @@ export function registerUserCRUDTools(server, gql) {
             return text({ error: error.message });
         }
     };
-    server.registerTool("affine_update_profile", {
-        title: "Update Profile",
-        description: "Update current user's profile information.",
-        inputSchema: {
-            name: z.string().optional().describe("Display name"),
-            avatarUrl: z.string().optional().describe("Avatar URL")
-        }
-    }, updateProfileHandler);
     server.registerTool("update_profile", {
         title: "Update Profile",
         description: "Update current user's profile information.",
@@ -47,163 +39,39 @@ export function registerUserCRUDTools(server, gql) {
         try {
             const mutation = `
         mutation UpdateSettings($input: UpdateUserSettingsInput!) {
-          updateSettings(input: $input) {
-            success
-          }
+          updateSettings(input: $input)
         }
       `;
+            const input = {};
+            if (typeof settings.receiveCommentEmail === 'boolean')
+                input.receiveCommentEmail = settings.receiveCommentEmail;
+            if (typeof settings.receiveInvitationEmail === 'boolean')
+                input.receiveInvitationEmail = settings.receiveInvitationEmail;
+            if (typeof settings.receiveMentionEmail === 'boolean')
+                input.receiveMentionEmail = settings.receiveMentionEmail;
+            if (Object.keys(input).length === 0) {
+                return text({
+                    error: "settings must include at least one of: receiveCommentEmail, receiveInvitationEmail, receiveMentionEmail",
+                });
+            }
             const data = await gql.request(mutation, {
-                input: settings
+                input
             });
-            return text(data.updateSettings);
+            return text({ success: data.updateSettings });
         }
         catch (error) {
             return text({ error: error.message });
         }
     };
-    server.registerTool("affine_update_settings", {
-        title: "Update Settings",
-        description: "Update user settings and preferences.",
-        inputSchema: {
-            settings: z.record(z.any()).describe("Settings object with key-value pairs")
-        }
-    }, updateSettingsHandler);
     server.registerTool("update_settings", {
         title: "Update Settings",
         description: "Update user settings and preferences.",
         inputSchema: {
-            settings: z.record(z.any()).describe("Settings object with key-value pairs")
+            settings: z.object({
+                receiveCommentEmail: z.boolean().optional(),
+                receiveInvitationEmail: z.boolean().optional(),
+                receiveMentionEmail: z.boolean().optional(),
+            }).describe("User notification settings")
         }
     }, updateSettingsHandler);
-    // SEND VERIFICATION EMAIL
-    const sendVerifyEmailHandler = async ({ callbackUrl }) => {
-        try {
-            const mutation = `
-        mutation SendVerifyEmail($callbackUrl: String!) {
-          sendVerifyEmail(callbackUrl: $callbackUrl)
-        }
-      `;
-            const data = await gql.request(mutation, {
-                callbackUrl: callbackUrl || `${process.env.AFFINE_BASE_URL}/verify`
-            });
-            return text({ success: data.sendVerifyEmail, message: "Verification email sent" });
-        }
-        catch (error) {
-            return text({ error: error.message });
-        }
-    };
-    server.registerTool("affine_send_verify_email", {
-        title: "Send Verification Email",
-        description: "Send email verification link.",
-        inputSchema: {
-            callbackUrl: z.string().optional().describe("Callback URL after verification")
-        }
-    }, sendVerifyEmailHandler);
-    server.registerTool("send_verify_email", {
-        title: "Send Verification Email",
-        description: "Send email verification link.",
-        inputSchema: {
-            callbackUrl: z.string().optional().describe("Callback URL after verification")
-        }
-    }, sendVerifyEmailHandler);
-    // CHANGE PASSWORD
-    const changePasswordHandler = async ({ token, newPassword, userId }) => {
-        try {
-            const mutation = `
-        mutation ChangePassword($token: String!, $newPassword: String!, $userId: String) {
-          changePassword(token: $token, newPassword: $newPassword, userId: $userId)
-        }
-      `;
-            const data = await gql.request(mutation, {
-                token,
-                newPassword,
-                userId
-            });
-            return text({ success: data.changePassword, message: "Password changed successfully" });
-        }
-        catch (error) {
-            return text({ error: error.message });
-        }
-    };
-    server.registerTool("affine_change_password", {
-        title: "Change Password",
-        description: "Change user password (requires token from email).",
-        inputSchema: {
-            token: z.string().describe("Password reset token from email"),
-            newPassword: z.string().describe("New password"),
-            userId: z.string().optional().describe("User ID")
-        }
-    }, changePasswordHandler);
-    server.registerTool("change_password", {
-        title: "Change Password",
-        description: "Change user password (requires token from email).",
-        inputSchema: {
-            token: z.string().describe("Password reset token from email"),
-            newPassword: z.string().describe("New password"),
-            userId: z.string().optional().describe("User ID")
-        }
-    }, changePasswordHandler);
-    // SEND PASSWORD RESET EMAIL
-    const sendPasswordResetHandler = async ({ callbackUrl }) => {
-        try {
-            const mutation = `
-        mutation SendChangePasswordEmail($callbackUrl: String!) {
-          sendChangePasswordEmail(callbackUrl: $callbackUrl)
-        }
-      `;
-            const data = await gql.request(mutation, {
-                callbackUrl: callbackUrl || `${process.env.AFFINE_BASE_URL}/reset-password`
-            });
-            return text({ success: data.sendChangePasswordEmail, message: "Password reset email sent" });
-        }
-        catch (error) {
-            return text({ error: error.message });
-        }
-    };
-    server.registerTool("affine_send_password_reset", {
-        title: "Send Password Reset",
-        description: "Send password reset email.",
-        inputSchema: {
-            callbackUrl: z.string().optional().describe("Callback URL for password reset")
-        }
-    }, sendPasswordResetHandler);
-    server.registerTool("send_password_reset", {
-        title: "Send Password Reset",
-        description: "Send password reset email.",
-        inputSchema: {
-            callbackUrl: z.string().optional().describe("Callback URL for password reset")
-        }
-    }, sendPasswordResetHandler);
-    // DELETE ACCOUNT
-    const deleteAccountHandler = async ({ confirm }) => {
-        if (!confirm) {
-            return text({ error: "Confirmation required. Set confirm: true to delete account." });
-        }
-        try {
-            const mutation = `
-        mutation DeleteAccount {
-          deleteAccount
-        }
-      `;
-            const data = await gql.request(mutation);
-            return text({ success: data.deleteAccount, message: "Account deleted successfully" });
-        }
-        catch (error) {
-            return text({ error: error.message });
-        }
-    };
-    server.registerTool("affine_delete_account", {
-        title: "Delete Account",
-        description: "Permanently delete user account. WARNING: This cannot be undone!",
-        inputSchema: {
-            confirm: z.literal(true).describe("Must be true to confirm account deletion")
-        }
-    }, deleteAccountHandler);
-    server.registerTool("delete_account", {
-        title: "Delete Account",
-        description: "Permanently delete user account. WARNING: This cannot be undone!",
-        inputSchema: {
-            confirm: z.literal(true).describe("Must be true to confirm account deletion")
-        }
-    }, deleteAccountHandler);
 }

package/dist/tools/workspaces.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import * as Y from "yjs";
 import FormData from "form-data";
 import fetch from "node-fetch";
-import { io } from "socket.io-client";
 import { text } from "../util/mcp.js";
+import { connectWorkspaceSocket, joinWorkspace, pushDocUpdate, wsUrlFromGraphQLEndpoint } from "../ws.js";
 // Generate AFFiNE-style document ID
 function generateDocId() {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
@@ -120,10 +120,6 @@ export function registerWorkspaceTools(server, gql) {
         title: "List Workspaces",
         description: "List all available AFFiNE workspaces"
     }, listWorkspacesHandler);
-    server.registerTool("affine_list_workspaces", {
-        title: "List Workspaces",
-        description: "List all available AFFiNE workspaces"
-    }, listWorkspacesHandler);
     // GET WORKSPACE
     const getWorkspaceHandler = async ({ id }) => {
         try {
@@ -153,13 +149,6 @@ export function registerWorkspaceTools(server, gql) {
             id: z.string().describe("Workspace ID")
         }
     }, getWorkspaceHandler);
-    server.registerTool("affine_get_workspace", {
-        title: "Get Workspace",
-        description: "Get details of a specific workspace",
-        inputSchema: {
-            id: z.string().describe("Workspace ID")
-        }
-    }, getWorkspaceHandler);
     // CREATE WORKSPACE
     const createWorkspaceHandler = async ({ name, avatar }) => {
         try {
@@ -208,70 +197,39 @@ export function registerWorkspaceTools(server, gql) {
                 throw new Error(result.errors[0].message);
             }
             const workspace = result.data.createWorkspace;
-            // Now create the actual document via WebSocket
-            const wsUrl = endpoint.replace('https://', 'wss://').replace('http://', 'ws://').replace('/graphql', '');
-            return new Promise((resolve) => {
-                const socket = io(wsUrl, {
-                    transports: ['websocket'],
-                    path: '/socket.io/',
-                    extraHeaders: cookie ? { Cookie: cookie } : undefined
-                });
-                socket.on('connect', () => {
-                    // Join the workspace
-                    socket.emit('space:join', {
-                        spaceType: 'workspace',
-                        spaceId: workspace.id
-                    });
-                    // Send the document update
-                    setTimeout(() => {
-                        const docUpdateBase64 = Buffer.from(docUpdate).toString('base64');
-                        socket.emit('space:push-doc-update', {
-                            spaceType: 'workspace',
-                            spaceId: workspace.id,
-                            docId: firstDocId,
-                            update: docUpdateBase64
-                        });
-                        // Wait longer for sync and disconnect
-                        setTimeout(() => {
-                            socket.disconnect();
-                            resolve(text({
-                                ...workspace,
-                                name: name,
-                                avatar: avatar,
-                                firstDocId: firstDocId,
-                                status: "success",
-                                message: "Workspace created successfully",
-                                url: `${process.env.AFFINE_BASE_URL}/workspace/${workspace.id}`
-                            }));
-                        }, 3000);
-                    }, 1000);
-                });
-                socket.on('error', () => {
+            const wsUrl = wsUrlFromGraphQLEndpoint(endpoint);
+            const baseUrl = process.env.AFFINE_BASE_URL || endpoint.replace(/\/graphql\/?$/, '');
+            try {
+                const socket = await connectWorkspaceSocket(wsUrl, cookie);
+                try {
+                    await joinWorkspace(socket, workspace.id);
+                    const docUpdateBase64 = Buffer.from(docUpdate).toString('base64');
+                    await pushDocUpdate(socket, workspace.id, firstDocId, docUpdateBase64);
+                }
+                finally {
                     socket.disconnect();
-                    // Even if WebSocket fails, workspace was created
-                    resolve(text({
-                        ...workspace,
-                        name: name,
-                        avatar: avatar,
-                        firstDocId: firstDocId,
-                        status: "partial",
-                        message: "Workspace created (document sync may be pending)",
-                        url: `${process.env.AFFINE_BASE_URL}/workspace/${workspace.id}`
-                    }));
+                }
+            }
+            catch (_wsError) {
+                // Keep workspace creation successful even if initial websocket sync fails.
+                return text({
+                    ...workspace,
+                    name,
+                    avatar,
+                    firstDocId,
+                    status: "partial",
+                    message: "Workspace created (document sync may be pending)",
+                    url: `${baseUrl}/workspace/${workspace.id}`
                 });
-                // Timeout
-                setTimeout(() => {
-                    socket.disconnect();
-                    resolve(text({
-                        ...workspace,
-                        name: name,
-                        avatar: avatar,
-                        firstDocId: firstDocId,
-                        status: "success",
-                        message: "Workspace created",
-                        url: `${process.env.AFFINE_BASE_URL}/workspace/${workspace.id}`
-                    }));
-                }, 10000);
+            }
+            return text({
+                ...workspace,
+                name,
+                avatar,
+                firstDocId,
+                status: "success",
+                message: "Workspace created successfully",
+                url: `${baseUrl}/workspace/${workspace.id}`
             });
         }
         catch (error) {
@@ -286,22 +244,6 @@ export function registerWorkspaceTools(server, gql) {
             avatar: z.string().optional().describe("Avatar emoji or URL")
         }
     }, createWorkspaceHandler);
-    server.registerTool("affine_create_workspace", {
-        title: "Create Workspace",
-        description: "Create a new workspace with initial document (accessible in UI)",
-        inputSchema: {
-            name: z.string().describe("Workspace name"),
-            avatar: z.string().optional().describe("Avatar emoji or URL")
-        }
-    }, createWorkspaceHandler);
-    server.registerTool("affine_create_workspace_fixed", {
-        title: "Create Workspace (Fixed)",
-        description: "Create a new workspace with initial document (backward compatible alias)",
-        inputSchema: {
-            name: z.string().describe("Workspace name"),
-            avatar: z.string().optional().describe("Avatar emoji or URL")
-        }
-    }, createWorkspaceHandler);
     // UPDATE WORKSPACE
     const updateWorkspaceHandler = async ({ id, public: isPublic, enableAi }) => {
         try {
@@ -310,12 +252,15 @@ export function registerWorkspaceTools(server, gql) {
             updateWorkspace(input: $input) {
               id
               public
+              enableAi
             }
           }
         `;
             const input = { id };
             if (isPublic !== undefined)
                 input.public = isPublic;
+            if (enableAi !== undefined)
+                input.enableAi = enableAi;
             const data = await gql.request(mutation, { input });
             return text(data.updateWorkspace);
         }
@@ -332,15 +277,6 @@ export function registerWorkspaceTools(server, gql) {
             enableAi: z.boolean().optional().describe("Enable AI features")
         }
     }, updateWorkspaceHandler);
-    server.registerTool("affine_update_workspace", {
-        title: "Update Workspace",
-        description: "Update workspace settings",
-        inputSchema: {
-            id: z.string().describe("Workspace ID"),
-            public: z.boolean().optional().describe("Make workspace public"),
-            enableAi: z.boolean().optional().describe("Enable AI features")
-        }
-    }, updateWorkspaceHandler);
     // DELETE WORKSPACE
     const deleteWorkspaceHandler = async ({ id }) => {
         try {
@@ -363,11 +299,4 @@ export function registerWorkspaceTools(server, gql) {
             id: z.string().describe("Workspace ID")
         }
     }, deleteWorkspaceHandler);
-    server.registerTool("affine_delete_workspace", {
-        title: "Delete Workspace",
-        description: "Delete a workspace permanently",
-        inputSchema: {
-            id: z.string().describe("Workspace ID")
-        }
-    }, deleteWorkspaceHandler);
 }

package/dist/ws.js

@@ -1,4 +1,7 @@
 import { io } from "socket.io-client";
+const DEFAULT_WS_CLIENT_VERSION = process.env.AFFINE_WS_CLIENT_VERSION || '0.26.0';
+const WS_CONNECT_TIMEOUT_MS = Number(process.env.AFFINE_WS_CONNECT_TIMEOUT_MS || 10000);
+const WS_ACK_TIMEOUT_MS = Number(process.env.AFFINE_WS_ACK_TIMEOUT_MS || 10000);
 export function wsUrlFromGraphQLEndpoint(endpoint) {
     return endpoint
         .replace('https://', 'wss://')
@@ -13,15 +16,22 @@ export async function connectWorkspaceSocket(wsUrl, cookie) {
             extraHeaders: cookie ? { Cookie: cookie } : undefined,
             autoConnect: true
         });
+        const timeout = setTimeout(() => {
+            cleanup();
+            socket.disconnect();
+            reject(new Error(`socket connect timeout after ${WS_CONNECT_TIMEOUT_MS}ms`));
+        }, WS_CONNECT_TIMEOUT_MS);
         const onError = (err) => {
             cleanup();
+            socket.disconnect();
             reject(err);
         };
         const onConnect = () => {
-            socket.off('connect_error', onError);
+            cleanup();
             resolve(socket);
         };
         const cleanup = () => {
+            clearTimeout(timeout);
             socket.off('connect', onConnect);
             socket.off('connect_error', onError);
         };
@@ -29,9 +39,13 @@ export async function connectWorkspaceSocket(wsUrl, cookie) {
         socket.on('connect_error', onError);
     });
 }
-export async function joinWorkspace(socket, workspaceId) {
+export async function joinWorkspace(socket, workspaceId, clientVersion = DEFAULT_WS_CLIENT_VERSION) {
     return new Promise((resolve, reject) => {
-        socket.emit('space:join', { spaceType: 'workspace', spaceId: workspaceId, clientVersion: 'mcp' }, (ack) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`space:join timeout after ${WS_ACK_TIMEOUT_MS}ms`));
+        }, WS_ACK_TIMEOUT_MS);
+        socket.emit('space:join', { spaceType: 'workspace', spaceId: workspaceId, clientVersion }, (ack) => {
+            clearTimeout(timeout);
             if (ack?.error)
                 return reject(new Error(ack.error.message || 'join failed'));
             resolve();
@@ -40,7 +54,11 @@ export async function joinWorkspace(socket, workspaceId) {
 }
 export async function loadDoc(socket, workspaceId, docId) {
     return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`space:load-doc timeout after ${WS_ACK_TIMEOUT_MS}ms`));
+        }, WS_ACK_TIMEOUT_MS);
         socket.emit('space:load-doc', { spaceType: 'workspace', spaceId: workspaceId, docId }, (ack) => {
+            clearTimeout(timeout);
             if (ack?.error) {
                 if (ack.error.name === 'DOC_NOT_FOUND')
                     return resolve({});
@@ -52,7 +70,11 @@ export async function loadDoc(socket, workspaceId, docId) {
 }
 export async function pushDocUpdate(socket, workspaceId, docId, updateBase64) {
     return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error(`space:push-doc-update timeout after ${WS_ACK_TIMEOUT_MS}ms`));
+        }, WS_ACK_TIMEOUT_MS);
         socket.emit('space:push-doc-update', { spaceType: 'workspace', spaceId: workspaceId, docId, update: updateBase64 }, (ack) => {
+            clearTimeout(timeout);
             if (ack?.error)
                 return reject(new Error(ack.error.message || 'push-doc-update failed'));
             resolve(ack?.data?.timestamp || Date.now());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "affine-mcp-server",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "private": false,
   "type": "module",
   "description": "Model Context Protocol server for AFFiNE - enables AI assistants to interact with AFFiNE workspaces, documents, and collaboration features.",
@@ -10,6 +10,10 @@
     "type": "git",
     "url": "git+https://github.com/dawncr0w/affine-mcp-server.git"
   },
+  "bugs": {
+    "url": "https://github.com/dawncr0w/affine-mcp-server/issues"
+  },
+  "homepage": "https://github.com/dawncr0w/affine-mcp-server#readme",
   "keywords": [
     "mcp",
     "affine",
@@ -23,10 +27,16 @@
     "affine-mcp": "bin/affine-mcp"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('fs').rmSync('dist',{ recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
-    "prepublishOnly": "npm run build"
+    "test": "npm run test:tool-manifest",
+    "test:tool-manifest": "node scripts/verify-tool-manifest.mjs",
+    "test:comprehensive": "node test-comprehensive.mjs",
+    "pack:check": "npm pack --dry-run",
+    "ci": "npm run build && npm run test:tool-manifest && npm run pack:check",
+    "prepublishOnly": "npm run ci"
   },
   "files": [
     "bin",
@@ -45,12 +55,12 @@
     "form-data": "^4.0.4",
     "node-fetch": "^3.3.2",
     "socket.io-client": "^4.8.1",
-    "undici": "^6.19.8",
+    "undici": "^7.21.0",
     "yjs": "^13.6.27",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/node": "^20.14.11",
+    "@types/node": "^25.2.3",
     "tsx": "^4.16.2",
     "typescript": "^5.5.4"
   }