affine-mcp-server 1.2.0

package/dist/tools/workspaces.js

@@ -0,0 +1,373 @@
+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";
+// Generate AFFiNE-style document ID
+function generateDocId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
+    let id = '';
+    for (let i = 0; i < 10; i++) {
+        id += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return id;
+}
+// Create initial workspace data with a document
+function createInitialWorkspaceData(workspaceName = 'New Workspace') {
+    // Create workspace root YDoc
+    const rootDoc = new Y.Doc();
+    // Set workspace metadata
+    const meta = rootDoc.getMap('meta');
+    meta.set('name', workspaceName);
+    meta.set('avatar', '');
+    // Create pages array with initial document
+    const pages = new Y.Array();
+    const firstDocId = generateDocId();
+    // Add first document metadata
+    const pageMetadata = new Y.Map();
+    pageMetadata.set('id', firstDocId);
+    pageMetadata.set('title', 'Welcome to ' + workspaceName);
+    pageMetadata.set('createDate', Date.now());
+    pageMetadata.set('tags', new Y.Array());
+    pages.push([pageMetadata]);
+    meta.set('pages', pages);
+    // Create settings
+    const setting = rootDoc.getMap('setting');
+    setting.set('collections', new Y.Array());
+    // Encode workspace update
+    const workspaceUpdate = Y.encodeStateAsUpdate(rootDoc);
+    // Create the actual document
+    const docYDoc = new Y.Doc();
+    const blocks = docYDoc.getMap('blocks');
+    // Create page block with proper structure
+    const pageId = generateDocId();
+    const pageBlock = new Y.Map();
+    pageBlock.set('sys:id', pageId);
+    pageBlock.set('sys:flavour', 'affine:page');
+    // Title as Y.Text
+    const titleText = new Y.Text();
+    titleText.insert(0, 'Welcome to ' + workspaceName);
+    pageBlock.set('prop:title', titleText);
+    // Children
+    const pageChildren = new Y.Array();
+    pageBlock.set('sys:children', pageChildren);
+    blocks.set(pageId, pageBlock);
+    // Add surface block (required)
+    const surfaceId = generateDocId();
+    const surfaceBlock = new Y.Map();
+    surfaceBlock.set('sys:id', surfaceId);
+    surfaceBlock.set('sys:flavour', 'affine:surface');
+    surfaceBlock.set('sys:parent', pageId);
+    surfaceBlock.set('sys:children', new Y.Array());
+    blocks.set(surfaceId, surfaceBlock);
+    pageChildren.push([surfaceId]);
+    // Add note block with xywh
+    const noteId = generateDocId();
+    const noteBlock = new Y.Map();
+    noteBlock.set('sys:id', noteId);
+    noteBlock.set('sys:flavour', 'affine:note');
+    noteBlock.set('sys:parent', pageId);
+    noteBlock.set('prop:displayMode', 'DocAndEdgeless');
+    noteBlock.set('prop:xywh', '[0,0,800,600]');
+    noteBlock.set('prop:index', 'a0');
+    noteBlock.set('prop:lockedBySelf', false);
+    const noteChildren = new Y.Array();
+    noteBlock.set('sys:children', noteChildren);
+    blocks.set(noteId, noteBlock);
+    pageChildren.push([noteId]);
+    // Add initial paragraph
+    const paragraphId = generateDocId();
+    const paragraphBlock = new Y.Map();
+    paragraphBlock.set('sys:id', paragraphId);
+    paragraphBlock.set('sys:flavour', 'affine:paragraph');
+    paragraphBlock.set('sys:parent', noteId);
+    paragraphBlock.set('sys:children', new Y.Array());
+    paragraphBlock.set('prop:type', 'text');
+    const paragraphText = new Y.Text();
+    paragraphText.insert(0, 'This workspace was created by AFFiNE MCP Server');
+    paragraphBlock.set('prop:text', paragraphText);
+    blocks.set(paragraphId, paragraphBlock);
+    noteChildren.push([paragraphId]);
+    // Set document metadata
+    const docMeta = docYDoc.getMap('meta');
+    docMeta.set('id', firstDocId);
+    docMeta.set('title', 'Welcome to ' + workspaceName);
+    docMeta.set('createDate', Date.now());
+    docMeta.set('tags', new Y.Array());
+    docMeta.set('version', 1);
+    // Encode document update
+    const docUpdate = Y.encodeStateAsUpdate(docYDoc);
+    return {
+        workspaceUpdate,
+        firstDocId,
+        docUpdate
+    };
+}
+export function registerWorkspaceTools(server, gql) {
+    // LIST WORKSPACES
+    const listWorkspacesHandler = async () => {
+        try {
+            const query = `query { workspaces { id public enableAi createdAt } }`;
+            const data = await gql.request(query);
+            return text(data.workspaces || []);
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("list_workspaces", {
+        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 {
+            const query = `query GetWorkspace($id: String!) { 
+        workspace(id: $id) { 
+          id 
+          public 
+          enableAi 
+          createdAt
+          permissions { 
+            Workspace_Read 
+            Workspace_CreateDoc 
+          } 
+        } 
+      }`;
+            const data = await gql.request(query, { id });
+            return text(data.workspace);
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("get_workspace", {
+        title: "Get Workspace",
+        description: "Get details of a specific workspace",
+        inputSchema: {
+            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 {
+            // Get endpoint and headers from GraphQL client
+            const endpoint = gql.endpoint || process.env.AFFINE_BASE_URL + '/graphql';
+            const headers = gql.headers || {};
+            const cookie = gql.cookie || headers.Cookie || '';
+            // Create initial workspace data
+            const { workspaceUpdate, firstDocId, docUpdate } = createInitialWorkspaceData(name);
+            // Only send workspace update - document will be created separately
+            const initData = Buffer.from(workspaceUpdate);
+            // Create multipart form
+            const form = new FormData();
+            // Add GraphQL operation
+            form.append('operations', JSON.stringify({
+                name: 'createWorkspace',
+                query: `mutation createWorkspace($init: Upload!) {
+            createWorkspace(init: $init) {
+              id
+              public
+              createdAt
+              enableAi
+            }
+          }`,
+                variables: { init: null }
+            }));
+            // Map file to variable
+            form.append('map', JSON.stringify({ '0': ['variables.init'] }));
+            // Add workspace init data
+            form.append('0', initData, {
+                filename: 'init.yjs',
+                contentType: 'application/octet-stream'
+            });
+            // Send request
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    ...headers,
+                    'Cookie': cookie,
+                    ...form.getHeaders()
+                },
+                body: form
+            });
+            const result = await response.json();
+            if (result.errors) {
+                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', () => {
+                    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}`
+                    }));
+                });
+                // 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);
+            });
+        }
+        catch (error) {
+            return text({ error: error.message, status: "failed" });
+        }
+    };
+    server.registerTool("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", {
+        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 {
+            const mutation = `
+          mutation UpdateWorkspace($input: UpdateWorkspaceInput!) {
+            updateWorkspace(input: $input) {
+              id
+              public
+            }
+          }
+        `;
+            const input = { id };
+            if (isPublic !== undefined)
+                input.public = isPublic;
+            const data = await gql.request(mutation, { input });
+            return text(data.updateWorkspace);
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("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);
+    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 {
+            const mutation = `
+          mutation DeleteWorkspace($id: String!) {
+            deleteWorkspace(id: $id)
+          }
+        `;
+            const data = await gql.request(mutation, { id });
+            return text({ success: data.deleteWorkspace, message: "Workspace deleted successfully" });
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("delete_workspace", {
+        title: "Delete Workspace",
+        description: "Delete a workspace permanently",
+        inputSchema: {
+            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/types.js

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

package/dist/util/mcp.js

@@ -0,0 +1,4 @@
+export function text(data) {
+    const text = typeof data === 'string' ? data : JSON.stringify(data);
+    return { content: [{ type: 'text', text }] };
+}

package/dist/ws.js

@@ -0,0 +1,64 @@
+import { io } from "socket.io-client";
+export function wsUrlFromGraphQLEndpoint(endpoint) {
+    return endpoint
+        .replace('https://', 'wss://')
+        .replace('http://', 'ws://')
+        .replace(/\/graphql\/?$/, '');
+}
+export async function connectWorkspaceSocket(wsUrl, cookie) {
+    return new Promise((resolve, reject) => {
+        const socket = io(wsUrl, {
+            transports: ['websocket'],
+            path: '/socket.io/',
+            extraHeaders: cookie ? { Cookie: cookie } : undefined,
+            autoConnect: true
+        });
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const onConnect = () => {
+            socket.off('connect_error', onError);
+            resolve(socket);
+        };
+        const cleanup = () => {
+            socket.off('connect', onConnect);
+            socket.off('connect_error', onError);
+        };
+        socket.on('connect', onConnect);
+        socket.on('connect_error', onError);
+    });
+}
+export async function joinWorkspace(socket, workspaceId) {
+    return new Promise((resolve, reject) => {
+        socket.emit('space:join', { spaceType: 'workspace', spaceId: workspaceId, clientVersion: 'mcp' }, (ack) => {
+            if (ack?.error)
+                return reject(new Error(ack.error.message || 'join failed'));
+            resolve();
+        });
+    });
+}
+export async function loadDoc(socket, workspaceId, docId) {
+    return new Promise((resolve, reject) => {
+        socket.emit('space:load-doc', { spaceType: 'workspace', spaceId: workspaceId, docId }, (ack) => {
+            if (ack?.error) {
+                if (ack.error.name === 'DOC_NOT_FOUND')
+                    return resolve({});
+                return reject(new Error(ack.error.message || 'load-doc failed'));
+            }
+            resolve(ack?.data || {});
+        });
+    });
+}
+export async function pushDocUpdate(socket, workspaceId, docId, updateBase64) {
+    return new Promise((resolve, reject) => {
+        socket.emit('space:push-doc-update', { spaceType: 'workspace', spaceId: workspaceId, docId, update: updateBase64 }, (ack) => {
+            if (ack?.error)
+                return reject(new Error(ack.error.message || 'push-doc-update failed'));
+            resolve(ack?.data?.timestamp || Date.now());
+        });
+    });
+}
+export function deleteDoc(socket, workspaceId, docId) {
+    socket.emit('space:delete-doc', { spaceType: 'workspace', spaceId: workspaceId, docId });
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "affine-mcp-server",
+  "version": "1.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Model Context Protocol server for AFFiNE - enables AI assistants to interact with AFFiNE workspaces, documents, and collaboration features.",
+  "author": "dawncr0w",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dawncr0w/affine-mcp-server.git"
+  },
+  "keywords": [
+    "mcp",
+    "affine",
+    "model-context-protocol",
+    "ai",
+    "claude",
+    "knowledge-base"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "affine-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.2",
+    "dotenv": "^16.6.1",
+    "form-data": "^4.0.4",
+    "node-fetch": "^3.3.2",
+    "socket.io-client": "^4.8.1",
+    "undici": "^6.19.8",
+    "yjs": "^13.6.27",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.11",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.4"
+  }
+}