affine-mcp-server 1.2.2 → 1.4.0

package/dist/tools/docs.js

@@ -4,6 +4,29 @@ import { wsUrlFromGraphQLEndpoint, connectWorkspaceSocket, joinWorkspace, loadDo
 import * as Y from "yjs";
 const WorkspaceId = z.string().min(1, "workspaceId required");
 const DocId = z.string().min(1, "docId required");
+const APPEND_BLOCK_TYPE_VALUES = [
+    "paragraph",
+    "heading1",
+    "heading2",
+    "heading3",
+    "quote",
+    "bulleted_list",
+    "numbered_list",
+    "todo",
+    "code",
+    "divider",
+];
+const AppendBlockType = z.enum(APPEND_BLOCK_TYPE_VALUES);
+function blockVersion(flavour) {
+    switch (flavour) {
+        case "affine:page":
+            return 2;
+        case "affine:surface":
+            return 5;
+        default:
+            return 1;
+    }
+}
 export function registerDocTools(server, gql, defaults) {
     // helpers
     function generateId() {
@@ -19,6 +42,182 @@ export function registerDocTools(server, gql, defaults) {
         const cookie = gql.cookie || headers.Cookie || '';
         return { endpoint, cookie };
     }
+    function makeText(content) {
+        const yText = new Y.Text();
+        if (content.length > 0) {
+            yText.insert(0, content);
+        }
+        return yText;
+    }
+    function asText(value) {
+        if (value instanceof Y.Text)
+            return value.toString();
+        if (typeof value === "string")
+            return value;
+        return "";
+    }
+    function childIdsFrom(value) {
+        if (!(value instanceof Y.Array))
+            return [];
+        const childIds = [];
+        value.forEach((entry) => {
+            if (typeof entry === "string") {
+                childIds.push(entry);
+                return;
+            }
+            if (Array.isArray(entry)) {
+                for (const child of entry) {
+                    if (typeof child === "string") {
+                        childIds.push(child);
+                    }
+                }
+            }
+        });
+        return childIds;
+    }
+    function setSysFields(block, blockId, flavour) {
+        block.set("sys:id", blockId);
+        block.set("sys:flavour", flavour);
+        block.set("sys:version", blockVersion(flavour));
+    }
+    function findBlockIdByFlavour(blocks, flavour) {
+        for (const [, value] of blocks) {
+            const block = value;
+            if (block?.get && block.get("sys:flavour") === flavour) {
+                return String(block.get("sys:id"));
+            }
+        }
+        return null;
+    }
+    function ensureNoteBlock(blocks) {
+        const existingNoteId = findBlockIdByFlavour(blocks, "affine:note");
+        if (existingNoteId) {
+            return existingNoteId;
+        }
+        const pageId = findBlockIdByFlavour(blocks, "affine:page");
+        if (!pageId) {
+            throw new Error("Document has no page block; unable to insert content.");
+        }
+        const noteId = generateId();
+        const note = new Y.Map();
+        setSysFields(note, noteId, "affine:note");
+        note.set("sys:parent", pageId);
+        note.set("sys:children", new Y.Array());
+        note.set("prop:xywh", "[0,0,800,95]");
+        note.set("prop:index", "a0");
+        note.set("prop:hidden", false);
+        note.set("prop:displayMode", "both");
+        const background = new Y.Map();
+        background.set("light", "#ffffff");
+        background.set("dark", "#252525");
+        note.set("prop:background", background);
+        blocks.set(noteId, note);
+        const page = blocks.get(pageId);
+        let pageChildren = page.get("sys:children");
+        if (!(pageChildren instanceof Y.Array)) {
+            pageChildren = new Y.Array();
+            page.set("sys:children", pageChildren);
+        }
+        pageChildren.push([noteId]);
+        return noteId;
+    }
+    function createBlock(noteId, parsed) {
+        const blockId = generateId();
+        const block = new Y.Map();
+        const content = parsed.text ?? "";
+        switch (parsed.type) {
+            case "paragraph":
+            case "heading1":
+            case "heading2":
+            case "heading3":
+            case "quote": {
+                setSysFields(block, blockId, "affine:paragraph");
+                block.set("sys:parent", noteId);
+                block.set("sys:children", new Y.Array());
+                const blockType = parsed.type === "heading1"
+                    ? "h1"
+                    : parsed.type === "heading2"
+                        ? "h2"
+                        : parsed.type === "heading3"
+                            ? "h3"
+                            : parsed.type === "quote"
+                                ? "quote"
+                                : "text";
+                block.set("prop:type", blockType);
+                block.set("prop:text", makeText(content));
+                return { blockId, block, flavour: "affine:paragraph", blockType };
+            }
+            case "bulleted_list":
+            case "numbered_list":
+            case "todo": {
+                setSysFields(block, blockId, "affine:list");
+                block.set("sys:parent", noteId);
+                block.set("sys:children", new Y.Array());
+                const blockType = parsed.type === "bulleted_list"
+                    ? "bulleted"
+                    : parsed.type === "numbered_list"
+                        ? "numbered"
+                        : "todo";
+                block.set("prop:type", blockType);
+                if (blockType === "todo") {
+                    block.set("prop:checked", Boolean(parsed.checked));
+                }
+                block.set("prop:text", makeText(content));
+                return { blockId, block, flavour: "affine:list", blockType };
+            }
+            case "code": {
+                setSysFields(block, blockId, "affine:code");
+                block.set("sys:parent", noteId);
+                block.set("sys:children", new Y.Array());
+                block.set("prop:language", (parsed.language || "txt").toLowerCase());
+                if (parsed.caption) {
+                    block.set("prop:caption", parsed.caption);
+                }
+                block.set("prop:text", makeText(content));
+                return { blockId, block, flavour: "affine:code" };
+            }
+            case "divider": {
+                setSysFields(block, blockId, "affine:divider");
+                block.set("sys:parent", noteId);
+                block.set("sys:children", new Y.Array());
+                return { blockId, block, flavour: "affine:divider" };
+            }
+        }
+    }
+    async function appendBlockInternal(parsed) {
+        const workspaceId = parsed.workspaceId || defaults.workspaceId;
+        if (!workspaceId)
+            throw new Error("workspaceId is required");
+        const { endpoint, cookie } = await getCookieAndEndpoint();
+        const wsUrl = wsUrlFromGraphQLEndpoint(endpoint);
+        const socket = await connectWorkspaceSocket(wsUrl, cookie);
+        try {
+            await joinWorkspace(socket, workspaceId);
+            const doc = new Y.Doc();
+            const snapshot = await loadDoc(socket, workspaceId, parsed.docId);
+            if (snapshot.missing) {
+                Y.applyUpdate(doc, Buffer.from(snapshot.missing, "base64"));
+            }
+            const prevSV = Y.encodeStateVector(doc);
+            const blocks = doc.getMap("blocks");
+            const noteId = ensureNoteBlock(blocks);
+            const { blockId, block, flavour, blockType } = createBlock(noteId, parsed);
+            blocks.set(blockId, block);
+            const note = blocks.get(noteId);
+            let noteChildren = note.get("sys:children");
+            if (!(noteChildren instanceof Y.Array)) {
+                noteChildren = new Y.Array();
+                note.set("sys:children", noteChildren);
+            }
+            noteChildren.push([blockId]);
+            const delta = Y.encodeStateAsUpdate(doc, prevSV);
+            await pushDocUpdate(socket, workspaceId, parsed.docId, Buffer.from(delta).toString("base64"));
+            return { appended: true, blockId, flavour, blockType };
+        }
+        finally {
+            socket.disconnect();
+        }
+    }
     const listDocsHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
         if (!workspaceId) {
@@ -38,16 +237,6 @@ export function registerDocTools(server, gql, defaults) {
             after: z.string().optional()
         }
     }, listDocsHandler);
-    server.registerTool("affine_list_docs", {
-        title: "List Documents",
-        description: "List documents in a workspace (GraphQL).",
-        inputSchema: {
-            workspaceId: z.string().describe("Workspace ID (optional if default set).").optional(),
-            first: z.number().optional(),
-            offset: z.number().optional(),
-            after: z.string().optional()
-        }
-    }, listDocsHandler);
     const getDocHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
         if (!workspaceId) {
@@ -65,78 +254,103 @@ export function registerDocTools(server, gql, defaults) {
             docId: DocId
         }
     }, getDocHandler);
-    server.registerTool("affine_get_doc", {
-        title: "Get Document",
-        description: "Get a document by ID (GraphQL metadata).",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            docId: DocId
+    const readDocHandler = async (parsed) => {
+        const workspaceId = parsed.workspaceId || defaults.workspaceId;
+        if (!workspaceId) {
+            throw new Error("workspaceId is required. Provide it as a parameter or set AFFINE_WORKSPACE_ID in environment.");
         }
-    }, getDocHandler);
-    const searchDocsHandler = async (parsed) => {
+        const { endpoint, cookie } = await getCookieAndEndpoint();
+        const wsUrl = wsUrlFromGraphQLEndpoint(endpoint);
+        const socket = await connectWorkspaceSocket(wsUrl, cookie);
         try {
-            const workspaceId = parsed.workspaceId || defaults.workspaceId;
-            if (!workspaceId) {
-                throw new Error("workspaceId is required. Provide it as a parameter or set AFFINE_WORKSPACE_ID in environment.");
+            await joinWorkspace(socket, workspaceId);
+            const snapshot = await loadDoc(socket, workspaceId, parsed.docId);
+            if (!snapshot.missing) {
+                return text({
+                    docId: parsed.docId,
+                    title: null,
+                    exists: false,
+                    blockCount: 0,
+                    blocks: [],
+                    plainText: "",
+                });
             }
-            const query = `query SearchDocs($workspaceId:String!, $keyword:String!, $limit:Int){ workspace(id:$workspaceId){ searchDocs(input:{ keyword:$keyword, limit:$limit }){ docId title highlight createdAt updatedAt } } }`;
-            const data = await gql.request(query, { workspaceId, keyword: parsed.keyword, limit: parsed.limit });
-            return text(data.workspace?.searchDocs || []);
-        }
-        catch (error) {
-            // Return empty array on error (search might not be available)
-            console.error("Search docs error:", error.message);
-            return text([]);
-        }
-    };
-    server.registerTool("search_docs", {
-        title: "Search Documents",
-        description: "Search documents in a workspace.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            keyword: z.string().min(1),
-            limit: z.number().optional()
-        }
-    }, searchDocsHandler);
-    server.registerTool("affine_search_docs", {
-        title: "Search Documents",
-        description: "Search documents in a workspace.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            keyword: z.string().min(1),
-            limit: z.number().optional()
+            const doc = new Y.Doc();
+            Y.applyUpdate(doc, Buffer.from(snapshot.missing, "base64"));
+            const blocks = doc.getMap("blocks");
+            const pageId = findBlockIdByFlavour(blocks, "affine:page");
+            const noteId = findBlockIdByFlavour(blocks, "affine:note");
+            const visited = new Set();
+            const blockRows = [];
+            const plainTextLines = [];
+            let title = "";
+            const visit = (blockId) => {
+                if (visited.has(blockId))
+                    return;
+                visited.add(blockId);
+                const raw = blocks.get(blockId);
+                if (!(raw instanceof Y.Map))
+                    return;
+                const flavour = raw.get("sys:flavour");
+                const parentId = raw.get("sys:parent");
+                const type = raw.get("prop:type");
+                const textValue = asText(raw.get("prop:text"));
+                const language = raw.get("prop:language");
+                const checked = raw.get("prop:checked");
+                const childIds = childIdsFrom(raw.get("sys:children"));
+                if (flavour === "affine:page") {
+                    title = asText(raw.get("prop:title")) || title;
+                }
+                if (textValue.length > 0) {
+                    plainTextLines.push(textValue);
+                }
+                blockRows.push({
+                    id: blockId,
+                    parentId: typeof parentId === "string" ? parentId : null,
+                    flavour: typeof flavour === "string" ? flavour : null,
+                    type: typeof type === "string" ? type : null,
+                    text: textValue.length > 0 ? textValue : null,
+                    checked: typeof checked === "boolean" ? checked : null,
+                    language: typeof language === "string" ? language : null,
+                    childIds,
+                });
+                for (const childId of childIds) {
+                    visit(childId);
+                }
+            };
+            if (pageId) {
+                visit(pageId);
+            }
+            else if (noteId) {
+                visit(noteId);
+            }
+            for (const [id] of blocks) {
+                const blockId = String(id);
+                if (!visited.has(blockId)) {
+                    visit(blockId);
+                }
+            }
+            return text({
+                docId: parsed.docId,
+                title: title || null,
+                exists: true,
+                blockCount: blockRows.length,
+                blocks: blockRows,
+                plainText: plainTextLines.join("\n"),
+            });
         }
-    }, searchDocsHandler);
-    const recentDocsHandler = async (parsed) => {
-        const workspaceId = parsed.workspaceId || defaults.workspaceId;
-        if (!workspaceId) {
-            throw new Error("workspaceId is required. Provide it as a parameter or set AFFINE_WORKSPACE_ID in environment.");
+        finally {
+            socket.disconnect();
         }
-        // Note: AFFiNE doesn't have a separate 'recentlyUpdatedDocs' field, just use docs
-        const query = `query RecentDocs($workspaceId:String!, $first:Int, $offset:Int, $after:String){ workspace(id:$workspaceId){ docs(pagination:{first:$first, offset:$offset, after:$after}){ totalCount pageInfo{ hasNextPage endCursor } edges{ cursor node{ id workspaceId title summary public defaultRole createdAt updatedAt } } } } }`;
-        const data = await gql.request(query, { workspaceId, first: parsed.first, offset: parsed.offset, after: parsed.after });
-        return text(data.workspace.docs);
     };
-    server.registerTool("recent_docs", {
-        title: "Recent Documents",
-        description: "List recently updated docs in a workspace.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            first: z.number().optional(),
-            offset: z.number().optional(),
-            after: z.string().optional()
-        }
-    }, recentDocsHandler);
-    server.registerTool("affine_recent_docs", {
-        title: "Recent Documents",
-        description: "List recently updated docs in a workspace.",
+    server.registerTool("read_doc", {
+        title: "Read Document Content",
+        description: "Read document block content via WebSocket snapshot (blocks + plain text).",
         inputSchema: {
-            workspaceId: z.string().optional(),
-            first: z.number().optional(),
-            offset: z.number().optional(),
-            after: z.string().optional()
-        }
-    }, recentDocsHandler);
+            workspaceId: WorkspaceId.optional(),
+            docId: DocId,
+        },
+    }, readDocHandler);
     const publishDocHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
         if (!workspaceId) {
@@ -155,15 +369,6 @@ export function registerDocTools(server, gql, defaults) {
             mode: z.enum(["Page", "Edgeless"]).optional()
         }
     }, publishDocHandler);
-    server.registerTool("affine_publish_doc", {
-        title: "Publish Document",
-        description: "Publish a doc (make public).",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            docId: z.string(),
-            mode: z.enum(["Page", "Edgeless"]).optional()
-        }
-    }, publishDocHandler);
     const revokeDocHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
         if (!workspaceId) {
@@ -181,14 +386,6 @@ export function registerDocTools(server, gql, defaults) {
             docId: z.string()
         }
     }, revokeDocHandler);
-    server.registerTool("affine_revoke_doc", {
-        title: "Revoke Document",
-        description: "Revoke a doc's public access.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            docId: z.string()
-        }
-    }, revokeDocHandler);
     // CREATE DOC (high-level)
     const createDocHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
@@ -205,8 +402,7 @@ export function registerDocTools(server, gql, defaults) {
             const blocks = ydoc.getMap('blocks');
             const pageId = generateId();
             const page = new Y.Map();
-            page.set('sys:id', pageId);
-            page.set('sys:flavour', 'affine:page');
+            setSysFields(page, pageId, "affine:page");
             const titleText = new Y.Text();
             titleText.insert(0, parsed.title || 'Untitled');
             page.set('prop:title', titleText);
@@ -215,21 +411,27 @@ export function registerDocTools(server, gql, defaults) {
             blocks.set(pageId, page);
             const surfaceId = generateId();
             const surface = new Y.Map();
-            surface.set('sys:id', surfaceId);
-            surface.set('sys:flavour', 'affine:surface');
+            setSysFields(surface, surfaceId, "affine:surface");
             surface.set('sys:parent', pageId);
             surface.set('sys:children', new Y.Array());
+            const elements = new Y.Map();
+            elements.set("type", "$blocksuite:internal:native$");
+            elements.set("value", new Y.Map());
+            surface.set("prop:elements", elements);
             blocks.set(surfaceId, surface);
             children.push([surfaceId]);
             const noteId = generateId();
             const note = new Y.Map();
-            note.set('sys:id', noteId);
-            note.set('sys:flavour', 'affine:note');
+            setSysFields(note, noteId, "affine:note");
             note.set('sys:parent', pageId);
-            note.set('prop:displayMode', 'DocAndEdgeless');
-            note.set('prop:xywh', '[0,0,800,600]');
+            note.set('prop:displayMode', 'both');
+            note.set('prop:xywh', '[0,0,800,95]');
             note.set('prop:index', 'a0');
-            note.set('prop:lockedBySelf', false);
+            note.set('prop:hidden', false);
+            const background = new Y.Map();
+            background.set("light", "#ffffff");
+            background.set("dark", "#252525");
+            note.set("prop:background", background);
             const noteChildren = new Y.Array();
             note.set('sys:children', noteChildren);
             blocks.set(noteId, note);
@@ -237,8 +439,7 @@ export function registerDocTools(server, gql, defaults) {
             if (parsed.content) {
                 const paraId = generateId();
                 const para = new Y.Map();
-                para.set('sys:id', paraId);
-                para.set('sys:flavour', 'affine:paragraph');
+                setSysFields(para, paraId, "affine:paragraph");
                 para.set('sys:parent', noteId);
                 para.set('sys:children', new Y.Array());
                 para.set('prop:type', 'text');
@@ -293,90 +494,15 @@ export function registerDocTools(server, gql, defaults) {
             content: z.string().optional(),
         },
     }, createDocHandler);
-    server.registerTool('affine_create_doc', {
-        title: 'Create Document',
-        description: 'Create a new AFFiNE document with optional content',
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            title: z.string().optional(),
-            content: z.string().optional(),
-        },
-    }, createDocHandler);
     // APPEND PARAGRAPH
     const appendParagraphHandler = async (parsed) => {
-        const workspaceId = parsed.workspaceId || defaults.workspaceId;
-        if (!workspaceId)
-            throw new Error('workspaceId is required');
-        const { endpoint, cookie } = await getCookieAndEndpoint();
-        const wsUrl = wsUrlFromGraphQLEndpoint(endpoint);
-        const socket = await connectWorkspaceSocket(wsUrl, cookie);
-        try {
-            await joinWorkspace(socket, workspaceId);
-            const doc = new Y.Doc();
-            const snapshot = await loadDoc(socket, workspaceId, parsed.docId);
-            if (snapshot.missing) {
-                Y.applyUpdate(doc, Buffer.from(snapshot.missing, 'base64'));
-            }
-            const prevSV = Y.encodeStateVector(doc);
-            const blocks = doc.getMap('blocks');
-            // find a note block
-            let noteId = null;
-            for (const [key, val] of blocks) {
-                const m = val;
-                if (m?.get && m.get('sys:flavour') === 'affine:note') {
-                    noteId = m.get('sys:id');
-                    break;
-                }
-            }
-            if (!noteId) {
-                // fallback: create a note under existing page
-                let pageId = null;
-                for (const [key, val] of blocks) {
-                    const m = val;
-                    if (m?.get && m.get('sys:flavour') === 'affine:page') {
-                        pageId = m.get('sys:id');
-                        break;
-                    }
-                }
-                if (!pageId)
-                    throw new Error('Doc has no page block');
-                const note = new Y.Map();
-                noteId = generateId();
-                note.set('sys:id', noteId);
-                note.set('sys:flavour', 'affine:note');
-                note.set('sys:parent', pageId);
-                note.set('prop:displayMode', 'DocAndEdgeless');
-                note.set('prop:xywh', '[0,0,800,600]');
-                note.set('prop:index', 'a0');
-                note.set('prop:lockedBySelf', false);
-                note.set('sys:children', new Y.Array());
-                blocks.set(noteId, note);
-                const page = blocks.get(pageId);
-                const children = page.get('sys:children');
-                children.push([noteId]);
-            }
-            const paragraphId = generateId();
-            const para = new Y.Map();
-            para.set('sys:id', paragraphId);
-            para.set('sys:flavour', 'affine:paragraph');
-            para.set('sys:parent', noteId);
-            para.set('sys:children', new Y.Array());
-            para.set('prop:type', 'text');
-            const ptext = new Y.Text();
-            ptext.insert(0, parsed.text);
-            para.set('prop:text', ptext);
-            blocks.set(paragraphId, para);
-            const note = blocks.get(noteId);
-            const noteChildren = note.get('sys:children');
-            noteChildren.push([paragraphId]);
-            const delta = Y.encodeStateAsUpdate(doc, prevSV);
-            const deltaB64 = Buffer.from(delta).toString('base64');
-            await pushDocUpdate(socket, workspaceId, parsed.docId, deltaB64);
-            return text({ appended: true, paragraphId });
-        }
-        finally {
-            socket.disconnect();
-        }
+        const result = await appendBlockInternal({
+            workspaceId: parsed.workspaceId,
+            docId: parsed.docId,
+            type: "paragraph",
+            text: parsed.text,
+        });
+        return text({ appended: result.appended, paragraphId: result.blockId });
     };
     server.registerTool('append_paragraph', {
         title: 'Append Paragraph',
@@ -387,15 +513,28 @@ export function registerDocTools(server, gql, defaults) {
             text: z.string(),
         },
     }, appendParagraphHandler);
-    server.registerTool('affine_append_paragraph', {
-        title: 'Append Paragraph',
-        description: 'Append a text paragraph block to a document',
+    const appendBlockHandler = async (parsed) => {
+        const result = await appendBlockInternal(parsed);
+        return text({
+            appended: result.appended,
+            blockId: result.blockId,
+            flavour: result.flavour,
+            type: result.blockType || null,
+        });
+    };
+    server.registerTool("append_block", {
+        title: "Append Block",
+        description: "Append a slash-command style block (heading/list/todo/code/divider/quote) to a document.",
         inputSchema: {
-            workspaceId: z.string().optional(),
-            docId: z.string(),
-            text: z.string(),
+            workspaceId: WorkspaceId.optional(),
+            docId: DocId,
+            type: AppendBlockType.describe("Block type to append"),
+            text: z.string().optional().describe("Block content text"),
+            checked: z.boolean().optional().describe("Todo state when type is todo"),
+            language: z.string().optional().describe("Code language when type is code"),
+            caption: z.string().optional().describe("Code caption when type is code"),
         },
-    }, appendParagraphHandler);
+    }, appendBlockHandler);
     // DELETE DOC
     const deleteDocHandler = async (parsed) => {
         const workspaceId = parsed.workspaceId || defaults.workspaceId;
@@ -441,9 +580,4 @@ export function registerDocTools(server, gql, defaults) {
         description: 'Delete a document and remove from workspace list',
         inputSchema: { workspaceId: z.string().optional(), docId: z.string() },
     }, deleteDocHandler);
-    server.registerTool('affine_delete_doc', {
-        title: 'Delete Document',
-        description: 'Delete a document and remove from workspace list',
-        inputSchema: { workspaceId: z.string().optional(), docId: z.string() },
-    }, deleteDocHandler);
 }

package/dist/tools/history.js

@@ -9,16 +9,6 @@ export function registerHistoryTools(server, gql, defaults) {
         const data = await gql.request(query, { workspaceId, guid: parsed.guid, take: parsed.take, before: parsed.before });
         return text(data.workspace.histories);
     };
-    server.registerTool("affine_list_histories", {
-        title: "List Histories",
-        description: "List doc histories (timestamps) for a doc.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            guid: z.string(),
-            take: z.number().optional(),
-            before: z.string().optional()
-        }
-    }, listHistoriesHandler);
     server.registerTool("list_histories", {
         title: "List Histories",
         description: "List doc histories (timestamps) for a doc.",
@@ -29,30 +19,4 @@ export function registerHistoryTools(server, gql, defaults) {
             before: z.string().optional()
         }
     }, listHistoriesHandler);
-    const recoverDocHandler = async (parsed) => {
-        const workspaceId = parsed.workspaceId || defaults.workspaceId || parsed.workspaceId;
-        if (!workspaceId)
-            throw new Error("workspaceId required (or set AFFINE_WORKSPACE_ID)");
-        const mutation = `mutation Recover($workspaceId:String!,$guid:String!,$timestamp:DateTime!){ recoverDoc(workspaceId:$workspaceId, guid:$guid, timestamp:$timestamp) }`;
-        const data = await gql.request(mutation, { workspaceId, guid: parsed.guid, timestamp: parsed.timestamp });
-        return text({ recoveredAt: data.recoverDoc });
-    };
-    server.registerTool("affine_recover_doc", {
-        title: "Recover Document",
-        description: "Recover a doc to a previous timestamp.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            guid: z.string(),
-            timestamp: z.string()
-        }
-    }, recoverDocHandler);
-    server.registerTool("recover_doc", {
-        title: "Recover Document",
-        description: "Recover a doc to a previous timestamp.",
-        inputSchema: {
-            workspaceId: z.string().optional(),
-            guid: z.string(),
-            timestamp: z.string()
-        }
-    }, recoverDocHandler);
 }