@mseep/affine-mcp-server 2.3.0

package/dist/toolSurface.js

@@ -0,0 +1,349 @@
+const ALL_TOOLS = [
+    "add_database_column",
+    "add_database_row",
+    "add_doc_to_collection",
+    "add_organize_link",
+    "add_surface_element",
+    "add_tag_to_doc",
+    "analyze_doc_fidelity",
+    "append_block",
+    "append_markdown",
+    "append_semantic_section",
+    "cleanup_blobs",
+    "clear_doc_property",
+    "compose_database_from_intent",
+    "create_collection",
+    "create_comment",
+    "create_custom_property",
+    "create_doc",
+    "create_doc_from_markdown",
+    "create_folder",
+    "create_semantic_page",
+    "create_tag",
+    "create_workspace",
+    "create_workspace_blueprint",
+    "current_user",
+    "delete_blob",
+    "delete_block",
+    "delete_collection",
+    "delete_comment",
+    "delete_custom_property",
+    "delete_database_row",
+    "delete_doc",
+    "delete_folder",
+    "delete_organize_link",
+    "delete_surface_element",
+    "delete_workspace",
+    "export_doc_markdown",
+    "export_with_fidelity_report",
+    "find_doc_by_title",
+    "generate_access_token",
+    "get_capabilities",
+    "get_collection",
+    "get_doc",
+    "get_doc_icon",
+    "get_edgeless_canvas",
+    "get_folder_icon",
+    "get_orphan_docs",
+    "get_workspace",
+    "inspect_template_structure",
+    "instantiate_template_native",
+    "list_access_tokens",
+    "list_children",
+    "list_collections",
+    "list_comments",
+    "list_doc_properties",
+    "list_docs",
+    "list_docs_by_tag",
+    "list_histories",
+    "list_notifications",
+    "list_organize_nodes",
+    "list_surface_elements",
+    "list_tags",
+    "list_workspace_tree",
+    "list_workspaces",
+    "move_doc",
+    "move_organize_node",
+    "publish_doc",
+    "read_all_notifications",
+    "read_database_cells",
+    "read_database_columns",
+    "read_doc",
+    "remove_doc_from_collection",
+    "remove_tag_from_doc",
+    "rename_folder",
+    "replace_doc_with_markdown",
+    "resolve_comment",
+    "revoke_access_token",
+    "revoke_doc",
+    "search_docs",
+    "set_doc_property",
+    "sign_in",
+    "update_collection",
+    "update_collection_rules",
+    "update_comment",
+    "update_database_row",
+    "update_doc_icon",
+    "update_doc_title",
+    "update_edgeless_block",
+    "update_folder_icon",
+    "update_frame_children",
+    "update_profile",
+    "update_settings",
+    "update_surface_element",
+    "update_workspace",
+    "upload_blob",
+];
+const TOOL_GROUPS = {
+    add_database_column: ["docs", "docs.database", "docs.write", "write"],
+    add_database_row: ["docs", "docs.database", "docs.write", "write"],
+    add_doc_to_collection: ["organize", "organize.collections", "organize.write", "write"],
+    add_organize_link: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    add_surface_element: ["docs", "docs.edgeless", "docs.surface", "docs.write", "write"],
+    add_tag_to_doc: ["docs", "docs.tags", "docs.write", "write"],
+    analyze_doc_fidelity: ["docs", "docs.read", "docs.export", "read"],
+    append_block: ["docs", "docs.write", "write"],
+    append_markdown: ["docs", "docs.markdown", "docs.write", "write"],
+    append_semantic_section: ["docs", "docs.semantic", "docs.write", "write"],
+    cleanup_blobs: ["blobs", "blobs.write", "cleanup", "destructive", "write"],
+    clear_doc_property: ["docs", "docs.properties", "docs.write", "write"],
+    compose_database_from_intent: ["docs", "docs.database", "docs.intent", "docs.write", "write"],
+    create_collection: ["organize", "organize.collections", "organize.write", "write"],
+    create_comment: ["comments", "comments.write", "write"],
+    create_custom_property: ["docs", "docs.properties", "docs.write", "write"],
+    create_doc: ["docs", "docs.write", "write"],
+    create_doc_from_markdown: ["docs", "docs.markdown", "docs.write", "write"],
+    create_folder: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    create_semantic_page: ["docs", "docs.semantic", "docs.write", "write"],
+    create_tag: ["docs", "docs.tags", "docs.write", "write"],
+    create_workspace: ["workspaces", "workspaces.write", "admin", "write"],
+    create_workspace_blueprint: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    current_user: ["users", "users.read", "read"],
+    delete_blob: ["blobs", "blobs.write", "destructive", "write"],
+    delete_block: ["docs", "docs.edgeless", "docs.write", "destructive", "write"],
+    delete_collection: ["organize", "organize.collections", "organize.write", "destructive", "write"],
+    delete_comment: ["comments", "comments.write", "destructive", "write"],
+    delete_custom_property: ["docs", "docs.properties", "docs.write", "destructive", "write"],
+    delete_database_row: ["docs", "docs.database", "docs.write", "destructive", "write"],
+    delete_doc: ["docs", "docs.write", "destructive", "write"],
+    delete_folder: ["organize", "organize.folders", "organize.write", "destructive", "experimental", "write"],
+    delete_organize_link: ["organize", "organize.folders", "organize.write", "destructive", "experimental", "write"],
+    delete_surface_element: ["docs", "docs.edgeless", "docs.surface", "docs.write", "destructive", "write"],
+    delete_workspace: ["workspaces", "workspaces.write", "admin", "destructive", "write"],
+    export_doc_markdown: ["docs", "docs.export", "docs.markdown", "docs.read", "read"],
+    export_with_fidelity_report: ["docs", "docs.export", "docs.markdown", "docs.read", "read"],
+    find_doc_by_title: ["docs", "docs.read", "read"],
+    generate_access_token: ["access_tokens", "access_tokens.write", "admin", "write"],
+    get_capabilities: ["docs", "docs.read", "read"],
+    get_collection: ["organize", "organize.collections", "organize.read", "read"],
+    get_doc: ["docs", "docs.read", "read"],
+    get_doc_icon: ["docs", "docs.read", "read"],
+    get_edgeless_canvas: ["docs", "docs.edgeless", "docs.surface", "docs.read", "read"],
+    get_folder_icon: ["organize", "organize.folders", "organize.read", "experimental", "read"],
+    get_orphan_docs: ["docs", "docs.tree", "docs.read", "read"],
+    get_workspace: ["workspaces", "workspaces.read", "read"],
+    inspect_template_structure: ["docs", "docs.template", "docs.read", "read"],
+    instantiate_template_native: ["docs", "docs.template", "docs.write", "write"],
+    list_access_tokens: ["access_tokens", "access_tokens.read", "admin", "read"],
+    list_children: ["docs", "docs.tree", "docs.read", "read"],
+    list_collections: ["organize", "organize.collections", "organize.read", "read"],
+    list_comments: ["comments", "comments.read", "read"],
+    list_doc_properties: ["docs", "docs.properties", "docs.read", "read"],
+    list_docs: ["docs", "docs.read", "read"],
+    list_docs_by_tag: ["docs", "docs.tags", "docs.read", "read"],
+    list_histories: ["history", "history.read", "read"],
+    list_notifications: ["notifications", "notifications.read", "read"],
+    list_organize_nodes: ["organize", "organize.folders", "organize.read", "experimental", "read"],
+    list_surface_elements: ["docs", "docs.edgeless", "docs.surface", "docs.read", "read"],
+    list_tags: ["docs", "docs.tags", "docs.read", "read"],
+    list_workspace_tree: ["docs", "docs.tree", "docs.read", "read"],
+    list_workspaces: ["workspaces", "workspaces.read", "read"],
+    move_doc: ["docs", "docs.tree", "docs.write", "write"],
+    move_organize_node: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    publish_doc: ["docs", "docs.share", "docs.write", "write"],
+    read_all_notifications: ["notifications", "notifications.write", "write"],
+    read_database_cells: ["docs", "docs.database", "docs.read", "read"],
+    read_database_columns: ["docs", "docs.database", "docs.read", "read"],
+    read_doc: ["docs", "docs.read", "read"],
+    remove_doc_from_collection: ["organize", "organize.collections", "organize.write", "write"],
+    remove_tag_from_doc: ["docs", "docs.tags", "docs.write", "write"],
+    rename_folder: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    replace_doc_with_markdown: ["docs", "docs.markdown", "docs.write", "write"],
+    resolve_comment: ["comments", "comments.write", "write"],
+    revoke_access_token: ["access_tokens", "access_tokens.write", "admin", "destructive", "write"],
+    revoke_doc: ["docs", "docs.share", "docs.write", "destructive", "write"],
+    search_docs: ["docs", "docs.read", "read"],
+    set_doc_property: ["docs", "docs.properties", "docs.write", "write"],
+    sign_in: ["users", "users.auth", "auth", "write"],
+    update_collection: ["organize", "organize.collections", "organize.write", "write"],
+    update_collection_rules: ["organize", "organize.collections", "organize.write", "write"],
+    update_comment: ["comments", "comments.write", "write"],
+    update_database_row: ["docs", "docs.database", "docs.write", "write"],
+    update_doc_icon: ["docs", "docs.write", "write"],
+    update_doc_title: ["docs", "docs.write", "write"],
+    update_edgeless_block: ["docs", "docs.edgeless", "docs.write", "write"],
+    update_folder_icon: ["organize", "organize.folders", "organize.write", "experimental", "write"],
+    update_frame_children: ["docs", "docs.edgeless", "docs.write", "write"],
+    update_profile: ["users", "users.write", "admin", "write"],
+    update_settings: ["users", "users.write", "admin", "write"],
+    update_surface_element: ["docs", "docs.edgeless", "docs.surface", "docs.write", "write"],
+    update_workspace: ["workspaces", "workspaces.write", "admin", "write"],
+    upload_blob: ["blobs", "blobs.write", "write"],
+};
+const READ_ONLY_TOOLS = new Set([
+    "analyze_doc_fidelity",
+    "current_user",
+    "export_doc_markdown",
+    "export_with_fidelity_report",
+    "find_doc_by_title",
+    "get_capabilities",
+    "get_collection",
+    "get_doc",
+    "get_doc_icon",
+    "get_edgeless_canvas",
+    "get_folder_icon",
+    "get_orphan_docs",
+    "get_workspace",
+    "inspect_template_structure",
+    "list_access_tokens",
+    "list_children",
+    "list_collections",
+    "list_comments",
+    "list_doc_properties",
+    "list_docs",
+    "list_docs_by_tag",
+    "list_histories",
+    "list_notifications",
+    "list_organize_nodes",
+    "list_surface_elements",
+    "list_tags",
+    "list_workspace_tree",
+    "list_workspaces",
+    "read_database_cells",
+    "read_database_columns",
+    "read_doc",
+    "search_docs",
+    "sign_in",
+]);
+const CORE_TOOLS = new Set([
+    "add_database_column",
+    "add_database_row",
+    "add_tag_to_doc",
+    "append_block",
+    "append_markdown",
+    "create_doc",
+    "create_doc_from_markdown",
+    "current_user",
+    "export_doc_markdown",
+    "find_doc_by_title",
+    "get_capabilities",
+    "get_doc",
+    "get_doc_icon",
+    "get_workspace",
+    "list_children",
+    "list_docs",
+    "list_docs_by_tag",
+    "list_tags",
+    "list_workspaces",
+    "read_database_cells",
+    "read_database_columns",
+    "read_doc",
+    "remove_tag_from_doc",
+    "replace_doc_with_markdown",
+    "search_docs",
+    "sign_in",
+    "update_database_row",
+    "update_doc_icon",
+    "update_doc_title",
+]);
+const AUTHORING_EXCLUDED_GROUPS = new Set([
+    "admin",
+    "cleanup",
+    "destructive",
+    "experimental",
+]);
+const KNOWN_PROFILES = new Set(["full", "read_only", "core", "authoring"]);
+const KNOWN_TOOLS = new Set(ALL_TOOLS);
+const KNOWN_GROUPS = new Set(Object.values(TOOL_GROUPS).flat());
+function parseCsv(raw, normalize = true) {
+    return (raw || "")
+        .split(",")
+        .map(value => value.trim())
+        .filter(Boolean)
+        .map(value => normalize ? value.toLowerCase() : value);
+}
+function normalizeProfile(raw) {
+    const value = (raw || "full").trim().toLowerCase();
+    if (KNOWN_PROFILES.has(value)) {
+        return { profile: value };
+    }
+    return {
+        profile: "full",
+        warning: `Unknown AFFINE_TOOL_PROFILE "${raw}". Using "full". Valid profiles: ${[...KNOWN_PROFILES].join(", ")}`,
+    };
+}
+function profileAllowsTool(profile, toolName) {
+    if (profile === "full") {
+        return true;
+    }
+    if (profile === "read_only") {
+        return READ_ONLY_TOOLS.has(toolName);
+    }
+    if (profile === "core") {
+        return CORE_TOOLS.has(toolName);
+    }
+    const groups = TOOL_GROUPS[toolName];
+    return !groups.some(group => AUTHORING_EXCLUDED_GROUPS.has(group));
+}
+export function createToolFilter(env = process.env) {
+    const profileResult = normalizeProfile(env.AFFINE_TOOL_PROFILE);
+    const disabledGroups = new Set(parseCsv(env.AFFINE_DISABLED_GROUPS));
+    const disabledTools = new Set(parseCsv(env.AFFINE_DISABLED_TOOLS));
+    const warnings = [];
+    if (profileResult.warning) {
+        warnings.push(profileResult.warning);
+    }
+    for (const group of disabledGroups) {
+        if (!KNOWN_GROUPS.has(group)) {
+            warnings.push(`Unknown group "${group}" in AFFINE_DISABLED_GROUPS. Valid groups: ${[...KNOWN_GROUPS].sort().join(", ")}`);
+        }
+    }
+    for (const tool of disabledTools) {
+        if (!KNOWN_TOOLS.has(tool)) {
+            warnings.push(`Unknown tool "${tool}" in AFFINE_DISABLED_TOOLS.`);
+        }
+    }
+    function isEnabled(name) {
+        const toolName = name;
+        if (!KNOWN_TOOLS.has(toolName)) {
+            return profileResult.profile === "full" && disabledGroups.size === 0 && disabledTools.size === 0;
+        }
+        if (disabledTools.has(toolName)) {
+            return false;
+        }
+        const groups = TOOL_GROUPS[toolName];
+        if (groups.some(group => disabledGroups.has(group))) {
+            return false;
+        }
+        return profileAllowsTool(profileResult.profile, toolName);
+    }
+    const enabledTools = ALL_TOOLS.filter(toolName => isEnabled(toolName));
+    return {
+        profile: profileResult.profile,
+        disabledGroups,
+        disabledTools,
+        warnings,
+        enabledTools,
+        totalToolCount: ALL_TOOLS.length,
+        isEnabled,
+    };
+}
+export function toolFilterRequiresRegisterTool(filter) {
+    return filter.profile !== "full" || filter.disabledGroups.size > 0 || filter.disabledTools.size > 0;
+}
+export function knownToolSurfaceGroups() {
+    return [...KNOWN_GROUPS].sort();
+}
+export function knownToolSurfaceProfiles() {
+    return [...KNOWN_PROFILES];
+}

package/dist/tools/accessTokens.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { text } from "../util/mcp.js";
+export function registerAccessTokenTools(server, gql) {
+    const listAccessTokensHandler = async () => {
+        try {
+            const query = `query { currentUser { accessTokens { id name createdAt expiresAt } } }`;
+            const data = await gql.request(query);
+            return text(data.currentUser?.accessTokens || []);
+        }
+        catch (error) {
+            console.error("List access tokens error:", error.message);
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("list_access_tokens", {
+        title: "List Access Tokens",
+        description: "List personal access tokens (metadata).",
+        inputSchema: {}
+    }, listAccessTokensHandler);
+    const generateAccessTokenHandler = async (parsed) => {
+        const mutation = `mutation($input: GenerateAccessTokenInput!){ generateUserAccessToken(input:$input){ id name createdAt expiresAt token } }`;
+        const data = await gql.request(mutation, { input: { name: parsed.name, expiresAt: parsed.expiresAt ?? null } });
+        return text(data.generateUserAccessToken);
+    };
+    server.registerTool("generate_access_token", {
+        title: "Generate Access Token",
+        description: "Generate a personal access token (returns token).",
+        inputSchema: {
+            name: z.string(),
+            expiresAt: z.string().optional()
+        }
+    }, generateAccessTokenHandler);
+    const revokeAccessTokenHandler = async (parsed) => {
+        const mutation = `mutation($id:String!){ revokeUserAccessToken(id:$id) }`;
+        const data = await gql.request(mutation, { id: parsed.id });
+        return text({ success: data.revokeUserAccessToken });
+    };
+    server.registerTool("revoke_access_token", {
+        title: "Revoke Access Token",
+        description: "Revoke a personal access token by id.",
+        inputSchema: {
+            id: z.string()
+        }
+    }, revokeAccessTokenHandler);
+}

package/dist/tools/auth.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { loginWithPassword } from "../auth.js";
+import { text } from "../util/mcp.js";
+export function registerAuthTools(server, gql, baseUrl) {
+    const signInHandler = async (parsed) => {
+        const { cookieHeader } = await loginWithPassword(baseUrl, parsed.email, parsed.password);
+        gql.setCookie(cookieHeader);
+        return text({ signedIn: true });
+    };
+    server.registerTool("sign_in", {
+        title: "Sign In",
+        description: "Sign in to AFFiNE using email and password; sets session cookies for subsequent calls.",
+        inputSchema: {
+            email: z.string().email(),
+            password: z.string().min(1)
+        }
+    }, signInHandler);
+}

package/dist/tools/blobStorage.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { text } from "../util/mcp.js";
+import FormData from "form-data";
+import fetch from "node-fetch";
+function decodeBlobContent(content) {
+    const normalized = content.trim().replace(/\s+/g, "");
+    const base64Like = normalized.length > 0 && normalized.length % 4 === 0 && /^[A-Za-z0-9+/=]+$/.test(normalized);
+    if (base64Like) {
+        try {
+            const decoded = Buffer.from(normalized, "base64");
+            if (decoded.length > 0) {
+                return decoded;
+            }
+        }
+        catch {
+            // Fallback to UTF-8 text below.
+        }
+    }
+    return Buffer.from(content, "utf8");
+}
+export function registerBlobTools(server, gql) {
+    // UPLOAD BLOB/FILE
+    const uploadBlobHandler = async ({ workspaceId, content, filename, contentType }) => {
+        try {
+            const endpoint = gql.endpoint;
+            const headers = gql.headers;
+            const cookie = gql.cookie;
+            const payload = decodeBlobContent(content);
+            const safeFilename = filename || `blob-${Date.now()}.bin`;
+            const mime = contentType || "application/octet-stream";
+            const form = new FormData();
+            form.append("operations", JSON.stringify({
+                query: `mutation SetBlob($workspaceId: String!, $blob: Upload!) {
+          setBlob(workspaceId: $workspaceId, blob: $blob)
+        }`,
+                variables: {
+                    workspaceId,
+                    blob: null
+                }
+            }));
+            form.append("map", JSON.stringify({ "0": ["variables.blob"] }));
+            form.append("0", payload, { filename: safeFilename, contentType: mime });
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    ...headers,
+                    Cookie: cookie,
+                    ...form.getHeaders(),
+                },
+                body: form,
+            });
+            const result = await response.json();
+            if (result.errors?.length) {
+                throw new Error(result.errors[0].message);
+            }
+            const blobKey = result.data?.setBlob;
+            if (!blobKey) {
+                throw new Error("Upload succeeded but no blob key was returned.");
+            }
+            return text({
+                id: blobKey,
+                key: blobKey,
+                workspaceId,
+                filename: safeFilename,
+                contentType: mime,
+                size: payload.length,
+                uploadedAt: new Date().toISOString()
+            });
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("upload_blob", {
+        title: "Upload Blob",
+        description: "Upload a file or blob to workspace storage.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace ID"),
+            content: z.string().describe("Base64 encoded content or text"),
+            filename: z.string().optional().describe("Filename"),
+            contentType: z.string().optional().describe("MIME type")
+        }
+    }, uploadBlobHandler);
+    // DELETE BLOB
+    const deleteBlobHandler = async ({ workspaceId, key, permanently = false }) => {
+        try {
+            const mutation = `
+        mutation DeleteBlob($workspaceId: String!, $key: String!, $permanently: Boolean) {
+          deleteBlob(workspaceId: $workspaceId, key: $key, permanently: $permanently)
+        }
+      `;
+            const data = await gql.request(mutation, {
+                workspaceId,
+                key,
+                permanently
+            });
+            return text({ success: data.deleteBlob, key, workspaceId, permanently });
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("delete_blob", {
+        title: "Delete Blob",
+        description: "Delete a blob/file from workspace storage.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace ID"),
+            key: z.string().describe("Blob key/ID to delete"),
+            permanently: z.boolean().optional().describe("Delete permanently")
+        }
+    }, deleteBlobHandler);
+    // RELEASE DELETED BLOBS
+    const cleanupBlobsHandler = async ({ workspaceId }) => {
+        try {
+            const mutation = `
+        mutation ReleaseDeletedBlobs($workspaceId: String!) {
+          releaseDeletedBlobs(workspaceId: $workspaceId)
+        }
+      `;
+            const data = await gql.request(mutation, {
+                workspaceId
+            });
+            return text({ success: true, workspaceId, blobsReleased: data.releaseDeletedBlobs });
+        }
+        catch (error) {
+            return text({ error: error.message });
+        }
+    };
+    server.registerTool("cleanup_blobs", {
+        title: "Cleanup Deleted Blobs",
+        description: "Permanently remove deleted blobs to free up storage.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace ID")
+        }
+    }, cleanupBlobsHandler);
+}

package/dist/tools/comments.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { receipt, text } from "../util/mcp.js";
+export function registerCommentTools(server, gql, defaults) {
+    const listCommentsHandler = 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 ListComments($workspaceId:String!,$docId:String!,$first:Int,$offset:Int,$after:String){ workspace(id:$workspaceId){ comments(docId:$docId, pagination:{first:$first, offset:$offset, after:$after}){ totalCount pageInfo{ hasNextPage endCursor } edges{ cursor node{ id content createdAt updatedAt resolved user{ id name avatarUrl } replies{ id content createdAt updatedAt user{ id name avatarUrl } } } } } } }`;
+        const data = await gql.request(query, { workspaceId, docId: parsed.docId, first: parsed.first, offset: parsed.offset, after: parsed.after });
+        return text(data.workspace.comments);
+    };
+    server.registerTool("list_comments", {
+        title: "List Comments",
+        description: "List comments of a doc (with replies).",
+        inputSchema: {
+            workspaceId: z.string().optional(),
+            docId: z.string(),
+            first: z.number().optional(),
+            offset: z.number().optional(),
+            after: z.string().optional()
+        }
+    }, listCommentsHandler);
+    const createCommentHandler = 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 CreateComment($input: CommentCreateInput!){ createComment(input:$input){ id content createdAt updatedAt resolved } }`;
+        const normalizedDocMode = (parsed.docMode || 'page').toLowerCase() === 'edgeless' ? 'edgeless' : 'page';
+        const normalizedContent = typeof parsed.content === 'string' ? { text: parsed.content } : parsed.content;
+        const input = { content: normalizedContent, docId: parsed.docId, workspaceId, docTitle: parsed.docTitle || "", docMode: normalizedDocMode, mentions: parsed.mentions };
+        const data = await gql.request(mutation, { input });
+        return receipt("comment.create", {
+            workspaceId,
+            docId: parsed.docId,
+            commentId: data.createComment.id,
+            id: data.createComment.id,
+            ...data.createComment,
+            comment: data.createComment,
+        });
+    };
+    server.registerTool("create_comment", {
+        title: "Create Comment",
+        description: "Create a comment on a doc.",
+        inputSchema: {
+            workspaceId: z.string().optional(),
+            docId: z.string(),
+            docTitle: z.string().optional(),
+            docMode: z.enum(["Page", "Edgeless", "page", "edgeless"]).optional(),
+            content: z.any(),
+            mentions: z.array(z.string()).optional()
+        }
+    }, createCommentHandler);
+    const updateCommentHandler = async (parsed) => {
+        const mutation = `mutation UpdateComment($input: CommentUpdateInput!){ updateComment(input:$input) }`;
+        const data = await gql.request(mutation, { input: { id: parsed.id, content: parsed.content } });
+        return receipt("comment.update", {
+            commentId: parsed.id,
+            id: parsed.id,
+            success: data.updateComment,
+        });
+    };
+    server.registerTool("update_comment", {
+        title: "Update Comment",
+        description: "Update a comment content.",
+        inputSchema: {
+            id: z.string(),
+            content: z.any()
+        }
+    }, updateCommentHandler);
+    const deleteCommentHandler = async (parsed) => {
+        const mutation = `mutation DeleteComment($id:String!){ deleteComment(id:$id) }`;
+        const data = await gql.request(mutation, { id: parsed.id });
+        return receipt("comment.delete", {
+            commentId: parsed.id,
+            id: parsed.id,
+            success: data.deleteComment,
+        });
+    };
+    server.registerTool("delete_comment", {
+        title: "Delete Comment",
+        description: "Delete a comment by id.",
+        inputSchema: {
+            id: z.string()
+        }
+    }, deleteCommentHandler);
+    const resolveCommentHandler = async (parsed) => {
+        const mutation = `mutation ResolveComment($input: CommentResolveInput!){ resolveComment(input:$input) }`;
+        const data = await gql.request(mutation, { input: parsed });
+        return receipt("comment.resolve", {
+            commentId: parsed.id,
+            id: parsed.id,
+            resolved: parsed.resolved,
+            success: data.resolveComment,
+        });
+    };
+    server.registerTool("resolve_comment", {
+        title: "Resolve Comment",
+        description: "Resolve or unresolve a comment.",
+        inputSchema: {
+            id: z.string(),
+            resolved: z.boolean()
+        }
+    }, resolveCommentHandler);
+}