friday-mcp-v2 2.0.0

package/dist/mcp-server.js

@@ -0,0 +1,1861 @@
+#!/usr/bin/env node
+/**
+ * F.R.I.D.A.Y. MCP Server v2.0
+ * WordPress REST API (HTTPS, App Password) 経由で直接通信
+ * Bridge Server / SharedState 不要
+ * Headless モード対応: エディタ未接続時は parse_blocks/serialize_blocks で直接操作
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { FridayWPClient, ConnectionRegistry } from "./wordpress-api.js";
+import fetch from "node-fetch";
+
+const registry = new ConnectionRegistry();
+
+// ヘルパー関数: 正規表現用に文字列をエスケープ
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Editor/Headless モード判定ヘルパー
+ * @returns {{ mode: 'editor'|'headless'|'error', postId?: number, message?: string, client?: FridayWPClient }}
+ */
+async function resolveMode(args) {
+    let client;
+    try {
+        client = registry.get(args?.site);
+    } catch (e) {
+        return { mode: 'error', message: e.message };
+    }
+
+    try {
+        const status = await client.getStatus();
+        if (status.editorConnected && status.postId) {
+            const argPostId = args?.postId;
+            if (argPostId && argPostId !== status.postId) {
+                return { mode: 'headless', postId: argPostId, client };
+            }
+            return { mode: 'editor', postId: status.postId, client };
+        }
+        const postId = args?.postId;
+        if (!postId) {
+            return { mode: 'error', message: 'エディタ未接続です。postId を指定して Headless モードを使用してください。' };
+        }
+        return { mode: 'headless', postId, client };
+    } catch (e) {
+        const postId = args?.postId;
+        if (postId) {
+            return { mode: 'headless', postId, client };
+        }
+        return { mode: 'error', message: `接続エラー: ${e.message}` };
+    }
+}
+
+// postId パラメータ定義（Headless 対応ツール共通）
+const postIdParam = {
+    type: "number",
+    description: "投稿ID（エディタ未接続時は必須）",
+};
+
+// site パラメータ定義（マルチ接続共通）
+const siteParam = {
+    type: "string",
+    description: "接続名（複数サイト/ユーザー設定時に指定。省略でデフォルト接続）",
+};
+
+// フィードバック送信ヘルパー
+const FEEDBACK_URL = process.env.FRIDAY_FEEDBACK_URL || '';
+async function sendFeedback(data) {
+    if (!FEEDBACK_URL) return;
+    try {
+        await fetch(FEEDBACK_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ ...data, version: '2.0.0' }),
+        });
+    } catch (_) {
+        // フィードバック送信失敗は無視（本体の動作に影響させない）
+    }
+}
+function errorResponse(toolName, message, site) {
+    sendFeedback({ tool: toolName, category: 'error', content: message, site: site || 'default' });
+    return { content: [{ type: "text", text: `❌ ${message}` }], isError: true };
+}
+
+// MCPサーバーの定義
+const server = new Server({
+    name: "friday-mcp-v2",
+    version: "2.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+
+// 利用可能なツールのリスト
+const tools = [
+    {
+        name: "get_article_structure",
+        description: "Get article structure (supports progressive loading: headings only by default, use parameters to zoom in)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                blockType: {
+                    type: "string",
+                    description: "Filter by block type (e.g. core/table) - shows all blocks of this type across sections",
+                },
+                section: {
+                    type: "string",
+                    description: "Zoom into specific section - shows all blocks in that section with details",
+                },
+                headingLevel: {
+                    type: "number",
+                    description: "Filter headings by level (2, 3, 4) - shows only headings of this level",
+                },
+                expand: {
+                    type: "number",
+                    description: "Container block index to expand (shows child blocks)",
+                },
+                contains: {
+                    type: "string",
+                    description: "Search text in block content - returns all matching blocks",
+                },
+                full: {
+                    type: "boolean",
+                    description: "Get full block data with all attributes (use with limit/offset for large articles)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of blocks to return (for pagination with full=true)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Starting block index for pagination (for pagination with full=true)",
+                },
+            },
+        },
+    },
+    {
+        name: "select_block",
+        description: "Select block(s) in WordPress editor. Index is 0-based flattened block position (including nested blocks).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                index: {
+                    type: "number",
+                    description: "Block index (0-based, flattened including nested blocks)",
+                },
+                blockType: {
+                    type: "string",
+                    description: "Block type (e.g. core/table)",
+                },
+                typeIndex: {
+                    type: "number",
+                    description: "N-th block of the type (0-based)",
+                },
+                contains: {
+                    type: "string",
+                    description: "Search text in block content",
+                },
+                startIndex: {
+                    type: "number",
+                    description: "Range selection start",
+                },
+                endIndex: {
+                    type: "number",
+                    description: "Range selection end",
+                },
+                headingLevel: {
+                    type: "number",
+                    description: "Heading level for section selection (2, 3, 4)",
+                },
+                headingContains: {
+                    type: "string",
+                    description: "Heading text for section selection",
+                },
+            },
+        },
+    },
+    {
+        name: "delete_block",
+        description: "Delete block(s) from the editor. Removes the block at the specified index or the currently selected block.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                index: { type: "number", description: "Block index to delete (0-based). If omitted, deletes selected block." },
+                count: { type: "number", description: "Number of consecutive blocks to delete (default: 1)" },
+                indices: { type: "array", items: { type: "number" }, description: "Multiple block indices to delete (0-based). Cannot be used with index/count." },
+            },
+        },
+    },
+    {
+        name: "move_block",
+        description: "Move a block to a different position. Use from/to for top-level blocks, or fromFlat/toFlat for any block (including nested).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                from: { type: "number", description: "Source top-level block index (0-based)" },
+                to: { type: "number", description: "Target position (0-based, can be length for end)" },
+                fromFlat: { type: "number", description: "Source flattened block index (0-based, supports nested blocks)" },
+                toFlat: { type: "number", description: "Target flattened position (pre-move basis, can be blockCount for end)" },
+            },
+        },
+    },
+    {
+        name: "undo",
+        description: "Undo the last editor action.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                steps: { type: "number", description: "Number of undo steps (default: 1)" },
+            },
+        },
+    },
+    {
+        name: "redo",
+        description: "Redo the last undone action.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                steps: { type: "number", description: "Number of redo steps (default: 1)" },
+            },
+        },
+    },
+    {
+        name: "duplicate_block",
+        description: "Duplicate a block. Duplicates the block at the specified index or the currently selected block.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                index: { type: "number", description: "Block index to duplicate (0-based). If omitted, duplicates selected block." },
+            },
+        },
+    },
+    {
+        name: "save_post",
+        description: "Save the current post (preserves current status).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+            },
+        },
+    },
+    {
+        name: "get_post_meta",
+        description: "Get post metadata (title, status, categories, tags, etc.).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+            },
+        },
+    },
+    {
+        name: "update_post_meta",
+        description: "Update post metadata (title, status, categories, tags, slug, excerpt, featured image).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                title: { type: "string", description: "Post title" },
+                status: { type: "string", enum: ["publish", "draft", "pending", "private"], description: "Post status" },
+                slug: { type: "string", description: "Post slug (URL)" },
+                categories: { type: "array", items: { type: "number" }, description: "Category IDs" },
+                tags: { type: "array", items: { type: "number" }, description: "Tag IDs" },
+                excerpt: { type: "string", description: "Post excerpt" },
+                featured_media: { type: "number", description: "Featured image media ID (0 to remove)" },
+            },
+        },
+    },
+    {
+        name: "list_posts",
+        description: "Search and list WordPress posts. Use to find postId for Headless mode operations. Default returns only published posts; use status='any' to include drafts. Search matches both title and content; use short single keywords for best results.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                search: { type: "string", description: "Search keyword (title/content)" },
+                status: { type: "string", enum: ["publish", "draft", "pending", "private", "any"], description: "Filter by status (default: publish)" },
+                categories: { type: "array", items: { type: "number" }, description: "Category IDs to filter by" },
+                tags: { type: "array", items: { type: "number" }, description: "Tag IDs to filter by" },
+                per_page: { type: "integer", description: "Results per page (1-100, default: 10)", minimum: 1, maximum: 100 },
+                page: { type: "integer", description: "Page number (default: 1)", minimum: 1 },
+                orderby: { type: "string", enum: ["date", "title", "modified", "id"], description: "Sort field (default: date)" },
+                order: { type: "string", enum: ["asc", "desc"], description: "Sort order (default: desc)" },
+            },
+        },
+    },
+    {
+        name: "list_taxonomies",
+        description: "List WordPress categories or tags. Use to find category/tag IDs for update_post_meta or list_posts filtering.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                type: { type: "string", enum: ["category", "tag"], description: "Taxonomy type (required)" },
+                search: { type: "string", description: "Search by name" },
+                per_page: { type: "integer", description: "Results per page (1-100, default: 10)", minimum: 1, maximum: 100 },
+                page: { type: "integer", description: "Page number (default: 1)", minimum: 1 },
+                orderby: { type: "string", enum: ["name", "id", "count", "slug"], description: "Sort field (default: name)" },
+                order: { type: "string", enum: ["asc", "desc"], description: "Sort order (default: asc)" },
+                hide_empty: { type: "boolean", description: "Hide terms with no posts (default: false)" },
+            },
+            required: ["type"],
+        },
+    },
+    {
+        name: "insert_block",
+        description: "Insert a new block at the specified position. If index is omitted, inserts at the end.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                blockType: { type: "string", description: "Block type (e.g. core/paragraph, core/heading, core/list)" },
+                content: { type: "string", description: "Block content (HTML or plain text depending on block type)" },
+                index: { type: "number", description: "Insert position (0-based flattened index). If omitted, appends to end." },
+                blocks: { type: "array", items: { type: "object", properties: { blockType: { type: "string" }, content: { type: "string" } }, required: ["blockType", "content"] }, description: "Multiple blocks to insert. Cannot be used with blockType/content." },
+                rawHTML: { type: "string", description: "Gutenberg markup HTML to insert directly. Cannot be used with blockType/content or blocks." },
+            },
+        },
+    },
+    {
+        name: "get_selection",
+        description: "Get lightweight info about the block currently selected by the user in WordPress editor. Returns type, index, and cursor-selected text only.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+            },
+        },
+    },
+    {
+        name: "get_block_html",
+        description: "Get serialized Gutenberg HTML (block comments included) for specified blocks. Use this before update_blocks with newHTML to safely edit custom/theme blocks.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                target: {
+                    type: "string",
+                    enum: ["selected"],
+                    description: "Use 'selected' to target the block currently selected by the user in WordPress editor.",
+                },
+                index: {
+                    type: "number",
+                    description: "Single block index (0-based flattened).",
+                },
+                indices: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Multiple block indices (0-based flattened).",
+                },
+                startIndex: {
+                    type: "number",
+                    description: "Range selection start index.",
+                },
+                endIndex: {
+                    type: "number",
+                    description: "Range selection end index.",
+                },
+                section: {
+                    type: "string",
+                    description: "Target section by heading text (partial match). Combines with blockType.",
+                },
+                blockType: {
+                    type: "string",
+                    description: "Filter by block type (e.g. core/table). Combines with section.",
+                },
+                typeIndex: {
+                    type: "number",
+                    description: "N-th block of the specified blockType (0-based). Use with blockType.",
+                },
+                headingLevel: {
+                    type: "number",
+                    description: "Heading level for section selection (2, 3, 4). Use with headingContains.",
+                },
+                headingContains: {
+                    type: "string",
+                    description: "Heading text for section selection. Use with headingLevel.",
+                },
+            },
+        },
+    },
+    {
+        name: "update_blocks",
+        description: "Update block(s) in WordPress editor. Combines targeting and modification in a single call. Supports single/multi/filter-based targeting with replacements, full HTML replace, or attribute updates.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                target: {
+                    type: "string",
+                    enum: ["selected"],
+                    description: "Use 'selected' to target the block currently selected by the user in WordPress editor.",
+                },
+                index: {
+                    type: "number",
+                    description: "Single block index (0-based flattened).",
+                },
+                indices: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Multiple block indices (0-based flattened).",
+                },
+                startIndex: {
+                    type: "number",
+                    description: "Range selection start index.",
+                },
+                endIndex: {
+                    type: "number",
+                    description: "Range selection end index.",
+                },
+                section: {
+                    type: "string",
+                    description: "Target section by heading text (partial match). Combines with blockType/contains.",
+                },
+                blockType: {
+                    type: "string",
+                    description: "Filter by block type (e.g. core/table). Combines with section/contains.",
+                },
+                typeIndex: {
+                    type: "number",
+                    description: "N-th block of the specified blockType (0-based). Use with blockType.",
+                },
+                contains: {
+                    type: "string",
+                    description: "Target blocks containing this text.",
+                },
+                headingLevel: {
+                    type: "number",
+                    description: "Heading level for section selection (2, 3, 4). Use with headingContains.",
+                },
+                headingContains: {
+                    type: "string",
+                    description: "Heading text for section selection. Use with headingLevel.",
+                },
+                replacements: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            old: { type: "string", description: "String to replace" },
+                            new: { type: "string", description: "Replacement string" },
+                            regex: { type: "boolean", description: "Treat 'old' as a regular expression pattern (default: false)" },
+                        },
+                        required: ["old", "new"],
+                    },
+                    description: "Diff-mode text replacements. Applied to serialized HTML of each target block.",
+                },
+                newHTML: {
+                    type: "string",
+                    description: "Full HTML replacement (Gutenberg markup). Only for contiguous targets (index/startIndex+endIndex/target:selected).",
+                },
+                attributeUpdates: {
+                    type: "object",
+                    properties: {
+                        filter: { type: "object", description: "Only update blocks matching these attributes (e.g. {alt: ''})" },
+                        set: { type: "object", description: "Attributes to set (e.g. {alt: 'new alt text'})" },
+                    },
+                    description: "Direct attribute updates via updateBlockAttributes API.",
+                },
+                insertOnly: {
+                    type: "boolean",
+                    description: "Keep existing blocks, insert newHTML as new blocks. Only with newHTML.",
+                },
+                insertPosition: {
+                    type: ["number", "string"],
+                    description: "Insert position when insertOnly=true. 'before', 'after' (default), or number.",
+                },
+                dryRun: {
+                    type: "boolean",
+                    description: "Preview changes without applying.",
+                },
+            },
+        },
+    },
+    {
+        name: "table_operations",
+        description: "Perform structured operations on core/table blocks (get structure, update cells, add/delete rows/columns, style cells/rows).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                postId: postIdParam,
+                site: siteParam,
+                index: {
+                    type: "number",
+                    description: "Table block's flattened index (0-based).",
+                },
+                action: {
+                    type: "string",
+                    enum: ["get_structure", "update_cell", "add_row", "delete_row", "add_column", "delete_column", "style_cell", "style_row"],
+                    description: "Operation type.",
+                },
+                row: {
+                    type: "number",
+                    description: "Row index (0-based, counting through thead/tbody/tfoot).",
+                },
+                col: {
+                    type: "number",
+                    description: "Column index (0-based).",
+                },
+                content: {
+                    type: "string",
+                    description: "Cell content (HTML allowed). Used by update_cell.",
+                },
+                position: {
+                    type: "number",
+                    description: "Insert position for add_row/add_column. Omit for end.",
+                },
+                cells: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Cell contents for new row (add_row). Omit for empty cells.",
+                },
+                style: {
+                    type: "object",
+                    properties: {
+                        backgroundColor: { type: "string", description: "Background color (e.g. #ff0000)" },
+                        color: { type: "string", description: "Text color" },
+                        fontWeight: { type: "string", description: "Font weight (bold, normal)" },
+                        textAlign: { type: "string", description: "Text alignment (left, center, right)" },
+                        fontSize: { type: "string", description: "Font size (e.g. 14px)" },
+                    },
+                    description: "Style for style_cell/style_row.",
+                },
+            },
+            required: ["index", "action"],
+        },
+    },
+    {
+        name: "list_connections",
+        description: "List available site/user connections.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "report_feedback",
+        description: "Report feedback, issues, or suggestions about MCP tools to the developer. Only use when the user explicitly requests to send feedback. Never use automatically without user consent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tool: {
+                    type: "string",
+                    description: "Tool name that the feedback is about (e.g. update_blocks, get_article_structure)",
+                },
+                category: {
+                    type: "string",
+                    enum: ["error", "feedback", "suggestion"],
+                    description: "Type of feedback: error (bug/failure), feedback (usability issue), suggestion (improvement idea)",
+                },
+                content: {
+                    type: "string",
+                    description: "Detailed description of the issue or suggestion",
+                },
+            },
+            required: ["content"],
+        },
+    },
+];
+
+// ツールリストのハンドラ
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+
+// ツール実行のハンドラ
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "get_article_structure": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { blockType, section, headingLevel, expand, contains, full, limit, offset } = (args || {});
+
+                // 使用パラメータを特定
+                const usedParams = [];
+                if (section) usedParams.push("section");
+                if (blockType) usedParams.push("blockType");
+                if (headingLevel) usedParams.push("headingLevel");
+                if (expand !== undefined) usedParams.push("expand");
+                if (contains) usedParams.push("contains");
+                if (full) usedParams.push("full");
+                if (limit && limit > 0) usedParams.push(`limit=${limit}`);
+                if (offset && offset > 0) usedParams.push(`offset=${offset}`);
+                const paramLabel = usedParams.length > 0 ? usedParams.join(" + ") : "default";
+
+                // Headless / Editor でデータ取得を分岐
+                let state;
+                if (mode === 'headless') {
+                    state = await client.headlessGetStructure(postId);
+                    // full/contains の場合は allBlocks が必要
+                    if (full || contains) {
+                        const blocksData = await client.headlessGetBlocks(postId);
+                        state.allBlocks = blocksData.blocks;
+                    }
+                } else {
+                    state = await client.getEditorState();
+                }
+
+                // ========================================
+                // 全ブロック情報取得（full=true）
+                // ========================================
+                if (full) {
+                    if (!state.allBlocks || state.allBlocks.length === 0) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n⚠️ 全ブロック情報がありません。${mode === 'editor' ? 'WordPressエディタで記事を開き直してください。' : '記事が見つかりません。'}`,
+                            }],
+                        };
+                    }
+
+                    let blocks = state.allBlocks;
+
+                    if (blockType) {
+                        blocks = blocks.filter(b => b.type === blockType);
+                    }
+                    if (section) {
+                        blocks = blocks.filter(b => b.section === section || b.section?.includes(section));
+                    }
+
+                    const totalCount = blocks.length;
+
+                    const startIdx = (offset && offset > 0) ? offset : 0;
+                    const endIdx = (limit && limit > 0) ? startIdx + limit : blocks.length;
+                    blocks = blocks.slice(startIdx, endIdx);
+
+                    const blockList = blocks.map(b => {
+                        const attrPreview = JSON.stringify(b.attributes || {}).slice(0, 200);
+                        return `  [${b.index}] ${b.type} - ${b.section || "(記事冒頭)"} (d:${b.depth})\n    ${attrPreview}${attrPreview.length >= 200 ? '...' : ''}`;
+                    }).join("\n\n");
+
+                    let paginationInfo = '';
+                    if (startIdx > 0 || endIdx < totalCount) {
+                        paginationInfo = `\n\n📄 表示: ${startIdx}〜${Math.min(endIdx, totalCount) - 1} / 全${totalCount}件`;
+                        if (endIdx < totalCount) {
+                            paginationInfo += `\n   次のページ: offset=${endIdx}`;
+                        }
+                    }
+
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n全ブロック情報 (${blocks.length}件):\n\n${blockList}${paginationInfo}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // コンテンツ検索
+                // ========================================
+                if (contains) {
+                    // allBlocks がある場合は MCP 側でフィルタ（高速）
+                    if (state.allBlocks && state.allBlocks.length > 0) {
+                        let matches = [];
+                        for (const block of state.allBlocks) {
+                            if (blockType && block.type !== blockType) continue;
+                            const attrJson = JSON.stringify(block.attributes || {});
+                            const htmlStr = block.html || '';
+                            // attributes → html の順で検索し、ヒット元を特定
+                            let hitSource = null;
+                            let hitIdx = -1;
+                            if (attrJson.includes(contains)) {
+                                hitSource = attrJson;
+                                hitIdx = attrJson.indexOf(contains);
+                            } else if (htmlStr.includes(contains)) {
+                                hitSource = htmlStr;
+                                hitIdx = htmlStr.indexOf(contains);
+                            }
+                            if (hitSource && hitIdx >= 0) {
+                                const start = Math.max(0, hitIdx - 20);
+                                const end = Math.min(hitSource.length, hitIdx + contains.length + 20);
+                                let preview = hitSource.slice(start, end);
+                                if (start > 0) preview = '...' + preview;
+                                if (end < hitSource.length) preview = preview + '...';
+                                matches.push({
+                                    index: block.index,
+                                    type: block.type,
+                                    section: block.section,
+                                    depth: block.depth,
+                                    preview: preview
+                                });
+                            }
+                        }
+
+                        if (matches.length === 0) {
+                            return {
+                                content: [{
+                                    type: "text",
+                                    text: `📊 get_article_structure(${paramLabel})\n\n"${contains}" を含むブロックは見つかりませんでした。`,
+                                }],
+                            };
+                        }
+
+                        const matchList = matches
+                            .map(m => {
+                                let line = `  index ${m.index}: ${m.type} - ${m.section || "(記事冒頭)"} (d:${m.depth})`;
+                                if (m.preview) {
+                                    line += `\n    "${m.preview}"`;
+                                }
+                                return line;
+                            })
+                            .join("\n");
+
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n"${contains}" を含むブロック (${matches.length}個):\n\n${matchList}`,
+                            }],
+                        };
+                    }
+
+                    // allBlocks がない場合 — Editor モードではオンデマンド検索
+                    if (mode === 'editor') {
+                        const searchResult = await client.searchBlocks(contains, blockType);
+
+                        if (!searchResult) {
+                            return {
+                                content: [{
+                                    type: "text",
+                                    text: `⏳ 検索タイムアウト: WordPressエディタが応答していません。`,
+                                }],
+                            };
+                            sendFeedback({ tool: name, category: 'error', content: '検索タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' });
+                        }
+
+                        if (searchResult.matches && searchResult.matches.length === 0) {
+                            return {
+                                content: [{
+                                    type: "text",
+                                    text: `📊 get_article_structure(${paramLabel})\n\n"${contains}" を含むブロックは見つかりませんでした。`,
+                                }],
+                            };
+                        }
+
+                        const matchList = (searchResult.matches || [])
+                            .map(m => {
+                                let line = `  index ${m.index}: ${m.type} - ${m.section || "(記事冒頭)"} (d:${m.depth})`;
+                                if (m.preview) {
+                                    line += `\n    "${m.preview}"`;
+                                }
+                                return line;
+                            })
+                            .join("\n");
+
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n"${contains}" を含むブロック (${(searchResult.matches || []).length}個):\n\n${matchList}`,
+                            }],
+                        };
+                    }
+
+                    // Headless で allBlocks なし — ありえないが安全ガード
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n⚠️ ブロック情報を取得できませんでした。`,
+                        }],
+                    };
+                }
+
+                // 見出し情報がない場合
+                if (!state.headings || state.headings.length === 0) {
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n記事構造がありません。${mode === 'editor' ? 'WordPressエディタで記事を開いてください。' : '記事が見つかりません。'}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // セクション + blockType の組み合わせ
+                // ========================================
+                if (section && blockType && state.blockSummary) {
+                    let sectionHeading = state.headings.find(h => h.text === section);
+                    if (!sectionHeading) {
+                        const candidates = state.headings.filter(h => h.text.includes(section));
+                        if (candidates.length === 1) sectionHeading = candidates[0];
+                    }
+                    if (!sectionHeading) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n❌ "${section}" に一致するセクションが見つかりません。`,
+                            }],
+                        };
+                    }
+
+                    const sectionIdx = state.headings.indexOf(sectionHeading);
+                    let nextSectionBlockIndex = null;
+                    for (let i = sectionIdx + 1; i < state.headings.length; i++) {
+                        if (state.headings[i].level <= sectionHeading.level) {
+                            nextSectionBlockIndex = state.headings[i].index;
+                            break;
+                        }
+                    }
+                    const startIdx = sectionHeading.index;
+                    const endIdx = nextSectionBlockIndex !== null ? nextSectionBlockIndex : Infinity;
+
+                    if (!state.blockSummary[blockType]) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n❌ ${blockType} は "${sectionHeading.text}" セクション内に存在しません。`,
+                            }],
+                        };
+                    }
+                    const filteredBlocks = state.blockSummary[blockType].blocks
+                        .filter(b => b.index > startIdx && b.index < endIdx);
+
+                    if (filteredBlocks.length === 0) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n❌ ${blockType} は "${sectionHeading.text}" セクション内に存在しません。`,
+                            }],
+                        };
+                    }
+
+                    const blockList = filteredBlocks
+                        .map(b => `  index ${b.index}: d:${b.depth || 0}`)
+                        .join("\n");
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n${sectionHeading.text} セクション内の ${blockType} (${filteredBlocks.length}個):\n\n${blockList}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // 特定ブロックタイプでフィルタ
+                // ========================================
+                if (blockType) {
+                    if (!state.blockSummary || !state.blockSummary[blockType]) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n❌ ${blockType} は記事内に存在しません。`,
+                            }],
+                        };
+                    }
+                    const typeData = state.blockSummary[blockType];
+                    const blockList = typeData.blocks
+                        .map(b => {
+                            let info = `  index ${b.index}: ${b.section || "(記事冒頭)"} (H${b.sectionLevel || "-"}) d:${b.depth || 0}`;
+                            if (b.tabNames && b.tabNames.length > 0) {
+                                info += ` [${b.tabNames.join(", ")}]`;
+                            } else if (b.columnCount) {
+                                info += ` [${b.columnCount}カラム]`;
+                            }
+                            return info;
+                        })
+                        .join("\n");
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n${blockType} の一覧 (${typeData.count}個):\n\n${blockList}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // 特定セクションでフィルタ
+                // ========================================
+                if (section && state.blockSummary) {
+                    let sectionHeading = state.headings.find(h => h.text === section);
+                    if (!sectionHeading) {
+                        const candidates = state.headings.filter(h => h.text.includes(section));
+                        if (candidates.length === 0) {
+                            return {
+                                content: [{
+                                    type: "text",
+                                    text: `📊 get_article_structure(${paramLabel})\n\n❌ "${section}" に一致するセクションが見つかりません。`,
+                                }],
+                            };
+                        }
+                        if (candidates.length > 1) {
+                            const candidateList = candidates
+                                .map(h => `  ${h.text} (H${h.level}, index:${h.index})`)
+                                .join("\n");
+                            return {
+                                content: [{
+                                    type: "text",
+                                    text: `📊 get_article_structure(${paramLabel})\n\n⚠️ "${section}" に複数のセクションが一致しました。より具体的に指定してください:\n\n${candidateList}`,
+                                }],
+                            };
+                        }
+                        sectionHeading = candidates[0];
+                    }
+
+                    const sectionIdx = state.headings.indexOf(sectionHeading);
+                    let nextSectionBlockIndex = null;
+                    for (let i = sectionIdx + 1; i < state.headings.length; i++) {
+                        if (state.headings[i].level <= sectionHeading.level) {
+                            nextSectionBlockIndex = state.headings[i].index;
+                            break;
+                        }
+                    }
+
+                    const sectionBlocks = [];
+                    const startIdx = sectionHeading.index;
+                    const endIdx = nextSectionBlockIndex !== null ? nextSectionBlockIndex : Infinity;
+
+                    for (const [type, data] of Object.entries(state.blockSummary)) {
+                        for (const block of data.blocks) {
+                            if (block.index > startIdx && block.index < endIdx) {
+                                sectionBlocks.push({ type, ...block });
+                            }
+                        }
+                    }
+                    sectionBlocks.sort((a, b) => a.index - b.index);
+
+                    const blockList = sectionBlocks
+                        .map(b => {
+                            const indent = '  '.repeat((b.depth || 0) + 1);
+                            let marker = '';
+                            let info = '';
+                            if (b.isContainer) {
+                                marker = '▼ ';
+                                if (b.columnCount) {
+                                    info = ` [${b.columnCount}カラム]`;
+                                } else if (b.tabNames && b.tabNames.length > 0) {
+                                    info = ` [${b.tabNames.join(", ")}]`;
+                                } else if (b.childCount) {
+                                    info = ` [${b.childCount}子]`;
+                                }
+                            }
+                            return `${indent}${b.index}: ${marker}${b.type}${info} (d:${b.depth || 0})`;
+                        })
+                        .join("\n");
+
+                    const nextInfo = nextSectionBlockIndex !== null
+                        ? `\n次のセクション: index ${nextSectionBlockIndex}`
+                        : "\n（最後のセクション）";
+
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\n${sectionHeading.text} セクション (index:${sectionHeading.index}):\n\n${blockList}${nextInfo}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // 特定レベルの見出しのみ
+                // ========================================
+                if (headingLevel) {
+                    const filteredHeadings = state.headings.filter(h => h.level === headingLevel);
+                    if (filteredHeadings.length === 0) {
+                        return {
+                            content: [{
+                                type: "text",
+                                text: `📊 get_article_structure(${paramLabel})\n\n❌ H${headingLevel}見出しは記事内に存在しません。`,
+                            }],
+                        };
+                    }
+                    const headingList = filteredHeadings
+                        .map(h => `  ${"#".repeat(h.level)} ${h.text} (index:${h.index})`)
+                        .join("\n");
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `📊 get_article_structure(${paramLabel})\n\nH${headingLevel}見出し一覧 (${filteredHeadings.length}個):\n\n${headingList}`,
+                        }],
+                    };
+                }
+
+                // ========================================
+                // デフォルト - 見出し構造のみ（軽量）
+                // ========================================
+                let output = `📊 get_article_structure(${paramLabel})\n\n見出し構造:\n\n`;
+
+                for (const heading of state.headings) {
+                    const indent = heading.level === 2 ? "" : "  ";
+                    const prefix = "#".repeat(heading.level);
+                    output += `${indent}${prefix} ${heading.text} (H${heading.level}, index:${heading.index})\n`;
+                }
+
+                return {
+                    content: [{ type: "text", text: output }],
+                };
+            }
+
+            case "select_block": {
+                const { mode, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+                if (mode !== 'editor') {
+                    return { content: [{ type: "text", text: `❌ select_block はエディタ接続時のみ使用可能です。` }], isError: true };
+                }
+
+                const { index, blockType, typeIndex, contains, startIndex, endIndex, headingLevel, headingContains } = (args || {});
+
+                try {
+                    await client.selectBlock({
+                        index, blockType, typeIndex, contains,
+                        startIndex, endIndex, headingLevel, headingContains
+                    });
+
+                    return {
+                        content: [{
+                            type: "text",
+                            text: `✅ ブロック選択リクエスト送信完了\n\n` +
+                                `次のステップ:\n` +
+                                `- get_selection で選択状態を確認\n` +
+                                `- update_blocks で編集`,
+                        }],
+                    };
+                } catch (error) {
+                    return {
+                        content: [{ type: "text", text: `❌ 選択失敗: ${error.message}` }],
+                        isError: true,
+                    };
+                }
+            }
+
+            case "delete_block": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { index, count, indices } = args;
+
+                // indices と index/count の排他バリデーション
+                if (indices !== undefined && (index !== undefined || count !== undefined)) {
+                    return { content: [{ type: "text", text: "❌ indices と index/count は同時に指定できません。" }], isError: true };
+                }
+
+                // indices モード（非連続一括削除）
+                if (indices !== undefined) {
+                    if (!Array.isArray(indices) || indices.length === 0) {
+                        return { content: [{ type: "text", text: "❌ indices は1つ以上の数値を含む配列で指定してください。" }], isError: true };
+                    }
+                    // 重複排除
+                    const uniqueIndices = [...new Set(indices)].filter(i => Number.isInteger(i));
+                    if (uniqueIndices.length === 0) {
+                        return { content: [{ type: "text", text: "❌ indices に有効な整数が含まれていません。" }], isError: true };
+                    }
+
+                    if (mode === 'headless') {
+                        const result = await client.headlessDeleteMultiple(postId, uniqueIndices);
+                        const details = result.deleted.map(d => `  [${d.index}] ${d.type}`).join('\n');
+                        return { content: [{ type: "text", text: `✅ ${result.count}ブロック削除\n\n${details}` }] };
+                    }
+
+                    const result = await client.sendEditorCommand("delete_block", { indices: uniqueIndices });
+                    if (!result)
+                        { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                    if (!result.success)
+                        return errorResponse(name, result.error, args?.site);
+                    const details = result.deleted.map(d => `  [${d.index}] ${d.type}`).join('\n');
+                    return { content: [{ type: "text", text: `✅ ${result.count}ブロック削除\n\n${details}` }] };
+                }
+
+                // 既存モード（index + count）
+                if (mode === 'headless') {
+                    if (index === undefined) {
+                        return { content: [{ type: "text", text: "❌ Headless モードでは index の指定が必須です。" }], isError: true };
+                    }
+                    const result = await client.headlessDelete(postId, index, count || 1);
+                    const details = result.deleted.map(d => `  [${d.index}] ${d.type}`).join('\n');
+                    return { content: [{ type: "text", text: `✅ ${result.count}ブロック削除\n\n${details}` }] };
+                }
+
+                const result = await client.sendEditorCommand("delete_block", { index, count });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                const details = result.deleted.map(d => `  [${d.index}] ${d.type}`).join('\n');
+                return { content: [{ type: "text", text: `✅ ${result.count}ブロック削除\n\n${details}` }] };
+            }
+
+            case "move_block": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { from, to, fromFlat, toFlat } = args;
+
+                // 排他バリデーション
+                const hasTopLevel = from !== undefined || to !== undefined;
+                const hasFlat = fromFlat !== undefined || toFlat !== undefined;
+                if (hasTopLevel && hasFlat) {
+                    return { content: [{ type: "text", text: "❌ from/to と fromFlat/toFlat は同時に指定できません。" }], isError: true };
+                }
+                if (!hasTopLevel && !hasFlat) {
+                    return { content: [{ type: "text", text: "❌ from/to または fromFlat/toFlat を指定してください。" }], isError: true };
+                }
+
+                // fromFlat/toFlat モード（フラットインデックス移動）
+                if (hasFlat) {
+                    if (fromFlat === undefined || toFlat === undefined) {
+                        return { content: [{ type: "text", text: "❌ fromFlat と toFlat の両方を指定してください。" }], isError: true };
+                    }
+                    if (fromFlat === toFlat) {
+                        return { content: [{ type: "text", text: "❌ fromFlat と toFlat が同じ位置です。" }], isError: true };
+                    }
+
+                    if (mode === 'headless') {
+                        const result = await client.headlessMoveFlat(postId, fromFlat, toFlat);
+                        return { content: [{ type: "text", text: `✅ ブロック移動: flat[${fromFlat}] → flat[${toFlat}] (${result.moved.type})` }] };
+                    }
+
+                    const result = await client.sendEditorCommand("move_block", { fromFlat, toFlat });
+                    if (!result)
+                        { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                    if (!result.success)
+                        return errorResponse(name, result.error, args?.site);
+                    return { content: [{ type: "text", text: `✅ ブロック移動: flat[${fromFlat}] → flat[${toFlat}] (${result.moved.type})` }] };
+                }
+
+                // 既存モード（from/to トップレベル）
+                if (from === undefined || to === undefined) {
+                    return { content: [{ type: "text", text: "❌ from と to の両方を指定してください" }], isError: true };
+                }
+
+                if (mode === 'headless') {
+                    const result = await client.headlessMove(postId, from, to);
+                    return { content: [{ type: "text", text: `✅ ブロック移動: [${from}] → [${to}] (${result.moved.type})` }] };
+                }
+
+                const result = await client.sendEditorCommand("move_block", { from, to });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                if (result.moved?.noop)
+                    return { content: [{ type: "text", text: `✅ 移動不要（同じ位置）` }] };
+                return { content: [{ type: "text", text: `✅ ブロック移動: [${from}] → [${to}] (${result.moved.type})` }] };
+            }
+
+            case "undo": {
+                const { mode, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+                if (mode !== 'editor') {
+                    return { content: [{ type: "text", text: `❌ undo はエディタ接続時のみ使用可能です。` }], isError: true };
+                }
+                const result = await client.sendEditorCommand("undo", { steps: args?.steps });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                return { content: [{ type: "text", text: `✅ ${result.done}回取り消し` }] };
+            }
+
+            case "redo": {
+                const { mode, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+                if (mode !== 'editor') {
+                    return { content: [{ type: "text", text: `❌ redo はエディタ接続時のみ使用可能です。` }], isError: true };
+                }
+                const result = await client.sendEditorCommand("redo", { steps: args?.steps });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                return { content: [{ type: "text", text: `✅ ${result.done}回やり直し` }] };
+            }
+
+            case "duplicate_block": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { index } = args;
+
+                if (mode === 'headless') {
+                    if (index === undefined) {
+                        return { content: [{ type: "text", text: "❌ Headless モードでは index の指定が必須です。" }], isError: true };
+                    }
+                    const result = await client.headlessDuplicate(postId, index);
+                    return { content: [{ type: "text", text: `✅ ブロック複製完了 (index ${result.duplicated.index} → ${result.duplicated.newIndex})` }] };
+                }
+
+                const result = await client.sendEditorCommand("duplicate_block", { index });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                return { content: [{ type: "text", text: `✅ ブロック複製完了` }] };
+            }
+
+            case "save_post": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                if (mode === 'headless') {
+                    // Headless モードでは即 DB 書き込みのため save は不要
+                    return { content: [{ type: "text", text: `✅ Headless モードでは変更は即時保存されています。` }] };
+                }
+
+                const result = await client.sendEditorCommand("save_post", {});
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                return { content: [{ type: "text", text: `✅ 保存完了` }] };
+            }
+
+            case "get_post_meta": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                let m;
+                if (mode === 'headless') {
+                    m = await client.headlessGetMeta(postId);
+                } else {
+                    const result = await client.sendEditorCommand("get_post_meta", {});
+                    if (!result)
+                        { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                    if (!result.success)
+                        return errorResponse(name, result.error, args?.site);
+                    m = result.meta;
+                }
+
+                const statusInfo = mode === 'editor'
+                    ? `モード: Editor (接続中)`
+                    : `モード: Headless (postId: ${postId})`;
+                const text = [
+                    `📄 投稿メタ情報`,
+                    ``,
+                    statusInfo,
+                    `ID: ${m.id}`,
+                    `タイトル: ${m.title}`,
+                    `ステータス: ${m.status}`,
+                    `スラッグ: ${m.slug}`,
+                    `URL: ${m.link}`,
+                    `カテゴリ: ${JSON.stringify(m.categories)}`,
+                    `タグ: ${JSON.stringify(m.tags)}`,
+                    `アイキャッチ: ${m.featuredImage || 'なし'}`,
+                    `抜粋: ${m.excerpt || 'なし'}`,
+                    `更新日: ${m.modified}`,
+                ].join('\n');
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "update_post_meta": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const updateData = {};
+                if (args.title !== undefined) updateData.title = args.title;
+                if (args.status !== undefined) updateData.status = args.status;
+                if (args.slug !== undefined) updateData.slug = args.slug;
+                if (args.categories !== undefined) updateData.categories = args.categories;
+                if (args.tags !== undefined) updateData.tags = args.tags;
+                if (args.excerpt !== undefined) updateData.excerpt = args.excerpt;
+                if (args.featured_media !== undefined) updateData.featured_media = args.featured_media;
+
+                if (Object.keys(updateData).length === 0) {
+                    return { content: [{ type: "text", text: "❌ 更新するフィールドを1つ以上指定してください" }], isError: true };
+                }
+
+                await client.updatePostMeta(postId, updateData);
+
+                const updated = Object.keys(updateData).map(k => `  ${k}: ${JSON.stringify(updateData[k])}`).join('\n');
+                let updateText = `✅ メタ情報更新完了 (postId: ${postId})\n\n${updated}`;
+
+                if (mode === 'editor') {
+                    updateText += `\n\n⚠️ エディタで同じ記事を開いています。エディタ側で未保存の変更がある場合、エディタの「保存」で上書きされる可能性があります。エディタをリロードしてください。`;
+                }
+
+                return { content: [{ type: "text", text: updateText }] };
+            }
+
+            case "list_posts": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+                const { data: posts, total, totalPages } = await client.listPosts(args || {});
+
+                if (!posts || posts.length === 0) {
+                    return { content: [{ type: "text", text: "📋 該当する投稿はありません。" }] };
+                }
+
+                const currentPage = args?.page || 1;
+                const list = posts.map(p => {
+                    return `  [${p.id}] ${p.title?.rendered || '(無題)'}\n` +
+                           `    ステータス: ${p.status} | 更新: ${p.modified?.split('T')[0] || '-'}\n` +
+                           `    URL: ${p.link || '-'}`;
+                }).join('\n\n');
+
+                let listText = `📋 投稿一覧 (${posts.length}件 / 全${total}件)\n\n${list}`;
+                if (totalPages > 1) {
+                    listText += `\n\n📄 ページ: ${currentPage} / ${totalPages}`;
+                    if (currentPage < totalPages) {
+                        listText += ` (次: page=${currentPage + 1})`;
+                    }
+                }
+
+                return { content: [{ type: "text", text: listText }] };
+            }
+
+            case "list_taxonomies": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const taxType = args?.type;
+                if (!taxType || !['category', 'tag'].includes(taxType)) {
+                    return { content: [{ type: "text", text: "❌ type は 'category' または 'tag' を指定してください" }], isError: true };
+                }
+
+                const { data: terms, total, totalPages } = await client.listTaxonomies(taxType, args || {});
+
+                if (!terms || terms.length === 0) {
+                    return { content: [{ type: "text", text: `📋 該当する${taxType === 'category' ? 'カテゴリ' : 'タグ'}はありません。` }] };
+                }
+
+                const label = taxType === 'category' ? 'カテゴリ' : 'タグ';
+                const currentPage = args?.page || 1;
+                const list = terms.map(t => {
+                    return `  [${t.id}] ${t.name}` +
+                           (t.count !== undefined ? ` (${t.count}件)` : '') +
+                           (t.parent ? ` 親: ${t.parent}` : '');
+                }).join('\n');
+
+                let text = `📋 ${label}一覧 (${terms.length}件 / 全${total}件)\n\n${list}`;
+                if (totalPages > 1) {
+                    text += `\n\n📄 ページ: ${currentPage} / ${totalPages}`;
+                    if (currentPage < totalPages) {
+                        text += ` (次: page=${currentPage + 1})`;
+                    }
+                }
+
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "insert_block": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { blockType, content, index, blocks, rawHTML } = args;
+
+                // 排他バリデーション
+                const hasLegacy = blockType !== undefined || content !== undefined;
+                const hasBlocks = blocks !== undefined;
+                const hasRawHTML = rawHTML !== undefined;
+                const modeCount = [hasLegacy, hasBlocks, hasRawHTML].filter(Boolean).length;
+                if (modeCount === 0) {
+                    return { content: [{ type: "text", text: "❌ blockType+content、blocks、rawHTML のいずれかを指定してください。" }], isError: true };
+                }
+                if (modeCount > 1) {
+                    return { content: [{ type: "text", text: "❌ blockType+content、blocks、rawHTML は同時に指定できません。" }], isError: true };
+                }
+
+                // 複数挿入モード (blocks / rawHTML)
+                if (hasBlocks || hasRawHTML) {
+                    if (hasBlocks && (!Array.isArray(blocks) || blocks.length === 0)) {
+                        return { content: [{ type: "text", text: "❌ blocks は1つ以上の要素を含む配列で指定してください。" }], isError: true };
+                    }
+
+                    if (mode === 'headless') {
+                        const params = { index };
+                        if (hasBlocks) params.blocks = blocks;
+                        if (hasRawHTML) params.rawHTML = rawHTML;
+                        const result = await client.headlessInsert(postId, params);
+                        const count = result.insertedIndices ? result.insertedIndices.length : result.count || 1;
+                        return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at ${index ?? 'end'}` }] };
+                    }
+
+                    const cmdParams = { index };
+                    if (hasBlocks) cmdParams.blocks = blocks;
+                    if (hasRawHTML) cmdParams.rawHTML = rawHTML;
+                    const result = await client.sendEditorCommand("insert_block", cmdParams);
+                    if (!result)
+                        { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                    if (!result.success)
+                        return errorResponse(name, result.error, args?.site);
+                    const count = result.insertedCount || result.inserted?.length || 1;
+                    return { content: [{ type: "text", text: `✅ ${count}ブロック挿入 at ${index ?? 'end'}` }] };
+                }
+
+                // 既存モード（単一 blockType + content）
+                if (!blockType || content === undefined) {
+                    return { content: [{ type: "text", text: "❌ blockType と content は必須です" }], isError: true };
+                }
+
+                if (mode === 'headless') {
+                    const result = await client.headlessInsert(postId, { blockType, content, index });
+                    return { content: [{ type: "text", text: `✅ ブロック挿入: ${blockType} at ${result.newIndex}` }] };
+                }
+
+                const result = await client.sendEditorCommand("insert_block", { blockType, content, index });
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+                return { content: [{ type: "text", text: `✅ ブロック挿入: ${result.inserted.type} at ${result.inserted.index}` }] };
+            }
+
+            case "get_block_html": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, headingLevel, headingContains } = (args || {});
+
+                if (mode === 'headless' && target === 'selected') {
+                    return {
+                        content: [{ type: "text", text: "❌ target:'selected' はエディタ接続時のみ使用可能です。index を指定してください。" }],
+                        isError: true,
+                    };
+                }
+
+                const hasTarget = target || index !== undefined || indices ||
+                    startIndex !== undefined || section || blockType ||
+                    (headingLevel && headingContains);
+                if (!hasTarget) {
+                    return {
+                        content: [{ type: "text", text: "❌ ターゲットが指定されていません。\ntarget, index, indices, section, blockType, contains 等のいずれかを指定してください。" }],
+                        isError: true,
+                    };
+                }
+
+                let blocks;
+                if (mode === 'headless') {
+                    const result = await client.headlessGetBlockHtml(postId, {
+                        index, indices, startIndex, endIndex,
+                        section, blockType, typeIndex,
+                        headingLevel, headingContains,
+                    });
+                    blocks = result.blocks || [];
+                } else {
+                    const result = await client.sendEditorCommand("get_block_html", { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, headingLevel, headingContains }, 10000);
+                    if (!result) {
+                        return errorResponse(name, 'タイムアウト: WordPress側からの応答がありません', args?.site);
+                    }
+                    if (result.error) {
+                        return errorResponse(name, result.error, args?.site);
+                    }
+                    blocks = result.blocks || [];
+                }
+
+                let text = `📦 ブロックHTML取得 (${blocks.length}件)\n`;
+                for (const b of blocks) {
+                    text += `\n[${b.index}] ${b.type}\n${b.html}\n`;
+                }
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "get_selection": {
+                const { mode, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+                if (mode !== 'editor') {
+                    return { content: [{ type: "text", text: `❌ get_selection はエディタ接続時のみ使用可能です。` }], isError: true };
+                }
+                const state = await client.getEditorState();
+                const sel = state.selectedBlock;
+
+                if (!sel || (!sel.blockId && !sel.blockIds)) {
+                    return {
+                        content: [{ type: "text", text: "ブロックが選択されていません。" }],
+                    };
+                }
+                // 複数選択
+                if (sel.isMultiSelect && sel.blockIds) {
+                    let text = `選択中: ${sel.blockIds.length}ブロック\n` +
+                        `タイプ: ${sel.blockTypes?.join(", ")}\n` +
+                        `位置: ${sel.blockIndices?.join(", ")}`;
+                    return { content: [{ type: "text", text }] };
+                }
+                // 単一選択
+                let text = `選択中: ${sel.blockType}\n` +
+                    `位置: index ${sel.blockIndex}`;
+                if (sel.textSelection?.text) {
+                    text += `\n\nカーソル選択テキスト: "${sel.textSelection.text}"`;
+                    if (sel.textSelection.context) {
+                        text += `\n  前: "...${sel.textSelection.context.before}"`;
+                        text += `\n  後: "${sel.textSelection.context.after}..."`;
+                    }
+                }
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "update_blocks": {
+                const { mode, postId: modePostId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { target, index, indices, startIndex, endIndex, section, blockType, typeIndex, contains, headingLevel, headingContains, replacements, newHTML, attributeUpdates, insertOnly, insertPosition, dryRun } = (args || {});
+
+                // Headless モードで target: "selected" はエラー
+                if (mode === 'headless' && target === 'selected') {
+                    return {
+                        content: [{ type: "text", text: "❌ target:'selected' はエディタ接続時のみ使用可能です。index を指定してください。" }],
+                        isError: true,
+                    };
+                }
+
+                const hasTarget = target || index !== undefined || indices ||
+                    startIndex !== undefined || section || blockType || contains ||
+                    (headingLevel && headingContains);
+                if (!hasTarget) {
+                    return {
+                        content: [{ type: "text", text: "❌ ターゲットが指定されていません。\ntarget, index, indices, section, blockType, contains 等のいずれかを指定してください。" }],
+                        isError: true,
+                    };
+                }
+
+                const hasUpdate = (replacements && replacements.length > 0) || newHTML || attributeUpdates;
+                if (!hasUpdate) {
+                    return {
+                        content: [{ type: "text", text: "❌ 変更内容が指定されていません。\nreplacements, newHTML, attributeUpdates のいずれかを指定してください。" }],
+                        isError: true,
+                    };
+                }
+
+                // ========================================
+                // Headless モード
+                // ========================================
+                if (mode === 'headless') {
+                    const result = await client.headlessUpdate(modePostId, {
+                        index, indices, startIndex, endIndex,
+                        section, blockType, typeIndex, contains,
+                        headingLevel, headingContains,
+                        replacements, newHTML, attributeUpdates,
+                        insertOnly: insertOnly || false,
+                        insertPosition,
+                        dryRun: dryRun || false,
+                    });
+
+                    if (result.dryRun && result.results) {
+                        const previewText = result.results
+                            .map(r => {
+                                const label = r.index !== undefined ? `[${r.index}]` :
+                                              r.indices ? `[${r.indices.join(', ')}]` : '[?]';
+                                return `  ${label}: ${r.preview ? 'プレビューあり' : 'N/A'}`;
+                            })
+                            .join('\n');
+                        return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText}` }] };
+                    }
+
+                    if (result.results) {
+                        const successCount = result.results.filter(r => r.success).length;
+                        const failCount = result.results.filter(r => !r.success).length;
+                        return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / 失敗: ${failCount}` }] };
+                    }
+
+                    return { content: [{ type: "text", text: `✅ 更新完了` }] };
+                }
+
+                // ========================================
+                // Editor モード（現行ロジック）
+                // ========================================
+
+                // target: "selected" の場合 → エディタ状態から選択情報を取得してMCP側で処理
+                if (target === "selected") {
+                    const state = await client.getEditorState();
+                    const sel = state.selectedBlock;
+
+                    if (!sel || (!sel.blockId && !sel.blockIds)) {
+                        return {
+                            content: [{ type: "text", text: "❌ ブロックが選択されていません。" }],
+                            isError: true,
+                        };
+                    }
+
+                    const blockIndices = sel.isMultiSelect ? sel.blockIndices : [sel.blockIndex];
+
+                    // replacementsの場合、MCP側でカーソル選択ピンポイント差分を適用
+                    if (replacements && replacements.length > 0) {
+                        if (!sel.blockHTML) {
+                            return {
+                                content: [{ type: "text", text: "❌ 選択中ブロックのHTML情報がありません。" }],
+                                isError: true,
+                            };
+                        }
+                        let finalHTML = sel.blockHTML;
+                        const hasTextSelection = sel.textSelection && sel.textSelection.text;
+                        for (const replacement of replacements) {
+                            if (!replacement.old || !replacement.new) continue;
+                            if (hasTextSelection && sel.textSelection) {
+                                const { text: selText, context } = sel.textSelection;
+                                const searchPattern = context.before + selText + context.after;
+                                if (finalHTML.includes(searchPattern)) {
+                                    const replacedPattern = context.before + replacement.new + context.after;
+                                    finalHTML = finalHTML.replace(searchPattern, replacedPattern);
+                                } else {
+                                    finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
+                                }
+                            } else {
+                                finalHTML = finalHTML.replace(new RegExp(escapeRegExp(replacement.old), 'g'), replacement.new);
+                            }
+                        }
+                        const result = await client.sendEditorCommand("update_blocks", {
+                            mode: "html_replace_by_index",
+                            blockIndices,
+                            newHTML: finalHTML,
+                            insertOnly: insertOnly || false,
+                            insertPosition,
+                        }, 10000);
+                        if (!result)
+                            { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                        if (!result.success)
+                            return errorResponse(name, result.error, args?.site);
+                        return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了${hasTextSelection ? "（カーソル選択モード）" : "（差分）"}` }] };
+                    }
+
+                    // newHTMLの場合
+                    if (newHTML) {
+                        const result = await client.sendEditorCommand("update_blocks", {
+                            mode: "html_replace_by_index",
+                            blockIndices,
+                            newHTML,
+                            insertOnly: insertOnly || false,
+                            insertPosition,
+                        }, 10000);
+                        if (!result)
+                            { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                        if (!result.success)
+                            return errorResponse(name, result.error, args?.site);
+                        return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了` }] };
+                    }
+
+                    // attributeUpdatesの場合
+                    const result = await client.sendEditorCommand("update_blocks", {
+                        mode: "attribute_update_by_index",
+                        blockIndices,
+                        attributeUpdates,
+                        dryRun: dryRun || false,
+                    }, 10000);
+                    if (!result)
+                        { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                    if (!result.success)
+                        return errorResponse(name, result.error, args?.site);
+                    return { content: [{ type: "text", text: `✅ 属性更新完了` }] };
+                }
+
+                // その他のターゲット → 全てWP側で解決＆実行
+                const maxWait = (section || blockType || contains) ? 15000 : 10000;
+                const result = await client.sendEditorCommand("update_blocks", {
+                    index, indices, startIndex, endIndex,
+                    section, blockType, typeIndex, contains,
+                    headingLevel, headingContains,
+                    replacements, newHTML, attributeUpdates,
+                    insertOnly: insertOnly || false,
+                    insertPosition,
+                    dryRun: dryRun || false,
+                }, maxWait);
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+
+                // 結果フォーマット
+                if (dryRun && result.results) {
+                    const previewText = result.results
+                        .filter(r => r.preview)
+                        .map(r => {
+                            if (Array.isArray(r.preview)) {
+                                return `  [${r.index}]\n${r.preview.map(p => `    "${p.old}" → "${p.new}" (${p.count}箇所)`).join('\n')}`;
+                            } else if (r.preview?.willUpdate) {
+                                return `  [${r.index}]: 属性更新予定 ${JSON.stringify(r.preview.willUpdate)}`;
+                            } else if (r.preview?.skipped) {
+                                return `  [${r.index}]: スキップ (${r.preview.skipped})`;
+                            }
+                            return `  [${r.index}]: プレビュー不可`;
+                        })
+                        .join('\n');
+                    return { content: [{ type: "text", text: `🔍 プレビュー\n\n対象: ${result.results.length} ブロック\n\n${previewText || "(対象なし)"}` }] };
+                }
+
+                if (result.results) {
+                    const successCount = result.results.filter(r => r.success && !r.skipped).length;
+                    const skipCount = result.results.filter(r => r.skipped).length;
+                    const failCount = result.results.filter(r => !r.success).length;
+                    const detailText = result.results.filter(r => r.success && r.replaceCount > 0).map(r => `  [${r.index}]: ${r.replaceCount}箇所`).join('\n');
+                    return { content: [{ type: "text", text: `✅ 完了\n\n成功: ${successCount} / スキップ: ${skipCount} / 失敗: ${failCount}\n\n${detailText}` }] };
+                }
+
+                return { content: [{ type: "text", text: `✅ ${result.mode === "insert" ? "挿入" : "更新"}完了` }] };
+            }
+
+            case "table_operations": {
+                const { mode, postId, message, client } = await resolveMode(args);
+                if (mode === 'error') {
+                    return errorResponse(name, message, args?.site);
+                }
+
+                const { index, action } = (args || {});
+                if (index === undefined) {
+                    return { content: [{ type: "text", text: "❌ index は必須です" }], isError: true };
+                }
+                if (!action) {
+                    return { content: [{ type: "text", text: "❌ action は必須です" }], isError: true };
+                }
+
+                const tableParams = {
+                    index, action,
+                    row: args.row, col: args.col,
+                    content: args.content, position: args.position,
+                    cells: args.cells, style: args.style,
+                };
+
+                // get_structure の結果をフォーマットするヘルパー
+                const formatStructure = (s) => {
+                    let text = `📊 テーブル構造 (index: ${index})\n`;
+                    text += `行数: ${s.totalRows}, 列数: ${s.totalCols}\n`;
+                    text += `ヘッダー: ${s.hasHeader ? 'あり' : 'なし'}, フッター: ${s.hasFooter ? 'あり' : 'なし'}\n`;
+                    for (const section of (s.sections || [])) {
+                        text += `\n[${section.type}]\n`;
+                        for (const row of section.rows) {
+                            const cellTexts = row.cells.map((c, ci) => {
+                                const content = c.content.replace(/<[^>]*>/g, '').trim();
+                                return `[${row.globalRow},${ci}] ${content || '(空)'}`;
+                            });
+                            text += `  行${row.globalRow}: ${cellTexts.join(' | ')}\n`;
+                        }
+                    }
+                    return text;
+                };
+
+                if (mode === 'headless') {
+                    const result = await client.headlessTableOperation(postId, tableParams);
+                    if (action === 'get_structure') {
+                        return { content: [{ type: "text", text: formatStructure(result) }] };
+                    }
+                    return { content: [{ type: "text", text: `✅ ${action} 完了: ${JSON.stringify(result.detail || result)}` }] };
+                }
+
+                // Editor モード
+                const result = await client.sendEditorCommand("table_operations", tableParams, 10000);
+                if (!result)
+                    { sendFeedback({ tool: name, category: 'error', content: 'タイムアウト: WordPressエディタが応答していません', site: args?.site || 'default' }); }
+                    return { content: [{ type: "text", text: "⏳ タイムアウト: WordPressエディタが応答していません。" }] };
+                if (!result.success)
+                    return errorResponse(name, result.error, args?.site);
+
+                if (action === 'get_structure') {
+                    return { content: [{ type: "text", text: formatStructure(result.structure) }] };
+                }
+                return { content: [{ type: "text", text: `✅ ${action} 完了: ${JSON.stringify(result.detail || {})}` }] };
+            }
+
+            case "list_connections": {
+                const conns = registry.list();
+                const text = conns.map(c => `  ${c.name}: ${c.url} (${c.user})`).join('\n');
+                return { content: [{ type: "text", text: `🔗 接続一覧 (${conns.length}件)\n\n${text}` }] };
+            }
+
+            case "report_feedback": {
+                if (!FEEDBACK_URL) {
+                    return { content: [{ type: "text", text: "⚠️ フィードバック送信先が未設定です（FRIDAY_FEEDBACK_URL）" }] };
+                }
+                await sendFeedback({
+                    tool: args?.tool || '',
+                    category: args?.category || 'feedback',
+                    content: args?.content || '',
+                });
+                return { content: [{ type: "text", text: `✅ フィードバックを送信しました` }] };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // エラー発生時に自動でフィードバック送信
+        sendFeedback({
+            tool: name,
+            category: 'error',
+            content: errorMessage,
+            site: args?.site || 'default',
+        });
+        return {
+            content: [{
+                type: "text",
+                text: `エラー: ${errorMessage}`,
+            }],
+            isError: true,
+        };
+    }
+});
+
+// サーバー起動
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    const conns = registry.list();
+    console.error("F.R.I.D.A.Y. MCP Server v2.0 running (WP REST API mode, Headless supported)");
+    console.error(`  接続数: ${conns.length}`);
+    for (const c of conns) {
+        console.error(`  [${c.name}] ${c.url} (${c.user})`);
+    }
+}
+main().catch((error) => {
+    console.error("MCP Server error:", error);
+    process.exit(1);
+});