affine-mcp-server 1.2.0

package/dist/tools/notifications.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { text } from "../util/mcp.js";
+export function registerNotificationTools(server, gql) {
+    // LIST NOTIFICATIONS
+    const listNotificationsHandler = async ({ first = 20, unreadOnly = false }) => {
+        try {
+            const query = `
+        query GetNotifications($first: Int!) {
+          currentUser {
+            notifications(first: $first) {
+              nodes {
+                id
+                type
+                title
+                body
+                read
+                createdAt
+              }
+              totalCount
+              pageInfo {
+                hasNextPage
+              }
+            }
+          }
+        }
+      `;
+            const data = await gql.request(query, { first });
+            let notifications = data.currentUser?.notifications?.nodes || [];
+            if (unreadOnly) {
+                notifications = notifications.filter((n) => !n.read);
+            }
+            return text(notifications);
+        }
+        catch (error) {
+            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"),
+            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 {
+            const mutation = `
+        mutation ReadAllNotifications {
+          readAllNotifications
+        }
+      `;
+            const data = await gql.request(mutation);
+            return text({ success: data.readAllNotifications, message: "All notifications marked as read" });
+        }
+        catch (error) {
+            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.",
+        inputSchema: {}
+    }, readAllNotificationsHandler);
+}

package/dist/tools/updates.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { text } from "../util/mcp.js";
+export function registerUpdateTools(server, gql, defaults) {
+    const applyDocUpdatesHandler = async (parsed) => {
+        const workspaceId = parsed.workspaceId || defaults.workspaceId || parsed.workspaceId;
+        if (!workspaceId)
+            throw new Error("workspaceId required (or set AFFINE_WORKSPACE_ID)");
+        const query = `query Apply($workspaceId:String!,$docId:String!,$op:String!,$updates:String!){ applyDocUpdates(workspaceId:$workspaceId, docId:$docId, op:$op, updates:$updates) }`;
+        const data = await gql.request(query, { workspaceId, docId: parsed.docId, op: parsed.op, updates: parsed.updates });
+        return text(data.applyDocUpdates);
+    };
+    server.registerTool("affine_apply_doc_updates", {
+        title: "Apply Document Updates",
+        description: "Apply CRDT updates to a doc (advanced).",
+        inputSchema: {
+            workspaceId: z.string().optional(),
+            docId: z.string(),
+            op: z.string(),
+            updates: z.string()
+        }
+    }, applyDocUpdatesHandler);
+    server.registerTool("apply_doc_updates", {
+        title: "Apply Document Updates",
+        description: "Apply CRDT updates to a doc (advanced).",
+        inputSchema: {
+            workspaceId: z.string().optional(),
+            docId: z.string(),
+            op: z.string(),
+            updates: z.string()
+        }
+    }, applyDocUpdatesHandler);
+}

package/dist/tools/user.js

@@ -0,0 +1,18 @@
+import { text } from "../util/mcp.js";
+export function registerUserTools(server, gql) {
+    const currentUserHandler = async () => {
+        const query = `query Me { currentUser { id name email emailVerified avatarUrl disabled } }`;
+        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.",
+        inputSchema: {}
+    }, currentUserHandler);
+}

package/dist/tools/userCRUD.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { text } from "../util/mcp.js";
+export function registerUserCRUDTools(server, gql) {
+    // UPDATE PROFILE
+    const updateProfileHandler = async ({ name, avatarUrl }) => {
+        try {
+            const mutation = `
+        mutation UpdateProfile($input: UpdateUserInput!) {
+          updateProfile(input: $input) {
+            id
+            name
+            avatarUrl
+            email
+          }
+        }
+      `;
+            const input = {};
+            if (name !== undefined)
+                input.name = name;
+            if (avatarUrl !== undefined)
+                input.avatarUrl = avatarUrl;
+            const data = await gql.request(mutation, { input });
+            return text(data.updateProfile);
+        }
+        catch (error) {
+            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.",
+        inputSchema: {
+            name: z.string().optional().describe("Display name"),
+            avatarUrl: z.string().optional().describe("Avatar URL")
+        }
+    }, updateProfileHandler);
+    // UPDATE SETTINGS
+    const updateSettingsHandler = async ({ settings }) => {
+        try {
+            const mutation = `
+        mutation UpdateSettings($input: UpdateUserSettingsInput!) {
+          updateSettings(input: $input) {
+            success
+          }
+        }
+      `;
+            const data = await gql.request(mutation, {
+                input: settings
+            });
+            return text(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")
+        }
+    }, 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);
+}