friday-mcp-v2 3.0.7 → 3.1.2

package/dist/mcp-server.js

@@ -14,7 +14,9 @@ import fetch from "node-fetch";
 import { randomUUID } from "node:crypto";
 import { readFileSync, statSync, realpathSync, appendFileSync, mkdirSync, existsSync, writeFileSync, renameSync } from "node:fs";
 import { execFile } from "node:child_process";
-import { resolve as resolvePath, sep, dirname, join as joinPath } from "node:path";
+import { resolve as resolvePath, sep, dirname, join as joinPath, extname } from "node:path";
+import { marked } from "marked";
+import { parse as parseHTML } from "node-html-parser";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 // package.json からバージョンを取得
@@ -456,6 +458,280 @@ function readHTMLFromFile(filePath, maxSizeBytes = 2 * 1024 * 1024) {
     return { html };
 }
 
+// ========================================
+// Markdown → Gutenberg Block Converter
+// ========================================
+
+function _convertHeading(node) {
+    const tag = node.tagName.toLowerCase();
+    const level = parseInt(tag[1]);
+    const attrs = level === 2 ? '' : ` {"level":${level}}`;
+    return `<!-- wp:heading${attrs} -->\n<${tag} class="wp-block-heading">${node.innerHTML}</${tag}>\n<!-- /wp:heading -->`;
+}
+
+function _convertParagraph(node) {
+    const img = node.querySelector('img');
+    if (img && node.childNodes.length === 1) {
+        return _convertImage(img);
+    }
+    return `<!-- wp:paragraph -->\n<p>${node.innerHTML}</p>\n<!-- /wp:paragraph -->`;
+}
+
+function _convertList(node) {
+    const tag = node.tagName.toLowerCase();
+    const ordered = tag === 'ol';
+    const attrs = ordered ? ' {"ordered":true}' : '';
+    const outerTag = ordered ? 'ol' : 'ul';
+    return `<!-- wp:list${attrs} -->\n<${outerTag} class="wp-block-list">${node.innerHTML}</${outerTag}>\n<!-- /wp:list -->`;
+}
+
+function _convertQuote(node) {
+    let inner = node.innerHTML.trim();
+    if (!inner.startsWith('<')) {
+        inner = `<p>${inner}</p>`;
+    }
+    return `<!-- wp:quote -->\n<blockquote class="wp-block-quote">${inner}</blockquote>\n<!-- /wp:quote -->`;
+}
+
+function _convertCode(node) {
+    const inner = node.innerHTML.replace(/<code\s+class="[^"]*">/g, '<code>');
+    return `<!-- wp:code -->\n<pre class="wp-block-code">${inner}</pre>\n<!-- /wp:code -->`;
+}
+
+function _convertTable(node) {
+    return `<!-- wp:table -->\n<figure class="wp-block-table"><table>${node.innerHTML}</table></figure>\n<!-- /wp:table -->`;
+}
+
+function _convertImage(node) {
+    const img = node.tagName?.toLowerCase() === 'img' ? node : node.querySelector('img');
+    if (!img) return `<!-- wp:html -->\n${node.outerHTML}\n<!-- /wp:html -->`;
+    const src = img.getAttribute('src') || '';
+    const alt = img.getAttribute('alt') || '';
+    return `<!-- wp:image -->\n<figure class="wp-block-image"><img src="${src}" alt="${alt}"/></figure>\n<!-- /wp:image -->`;
+}
+
+function htmlToGutenbergBlocks(html) {
+    const root = parseHTML(html);
+    const blocks = [];
+    for (const node of root.childNodes) {
+        if (node.nodeType === 3) {
+            const text = node.text.trim();
+            if (!text) continue;
+            blocks.push(`<!-- wp:paragraph -->\n<p>${text}</p>\n<!-- /wp:paragraph -->`);
+            continue;
+        }
+        if (node.nodeType !== 1) continue;
+        const tag = node.tagName?.toLowerCase();
+        switch (tag) {
+            case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
+                blocks.push(_convertHeading(node));
+                break;
+            case 'p':
+                blocks.push(_convertParagraph(node));
+                break;
+            case 'ul': case 'ol':
+                blocks.push(_convertList(node));
+                break;
+            case 'blockquote':
+                blocks.push(_convertQuote(node));
+                break;
+            case 'pre':
+                blocks.push(_convertCode(node));
+                break;
+            case 'hr':
+                blocks.push(`<!-- wp:separator -->\n<hr class="wp-block-separator has-alpha-channel-opacity"/>\n<!-- /wp:separator -->`);
+                break;
+            case 'table':
+                blocks.push(_convertTable(node));
+                break;
+            case 'figure':
+            case 'img':
+                blocks.push(_convertImage(node));
+                break;
+            default:
+                blocks.push(`<!-- wp:html -->\n${node.outerHTML}\n<!-- /wp:html -->`);
+                break;
+        }
+    }
+    return blocks.join('\n\n');
+}
+
+async function resolveFileToBlockHTML(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const raw = readHTMLFromFile(filePath).html;
+    if (ext === '.md') {
+        const html = await marked.parse(raw);
+        return htmlToGutenbergBlocks(html);
+    } else if (ext === '.html' || ext === '.htm') {
+        return raw;
+    } else {
+        throw new Error(`対応していないファイル形式です: ${ext} (.md または .html のみ)`);
+    }
+}
+
+// ========================================
+// Media Utilities
+// ========================================
+
+const ALLOWED_IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.avif']);
+const MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024; // 10MB
+
+const MIME_MAP = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.avif': 'image/avif',
+};
+
+function validateImageFile(filePath) {
+    const resolved = resolvePath(filePath);
+    let stat;
+    try { stat = statSync(resolved); }
+    catch (e) {
+        if (e.code === 'ENOENT') throw new Error(`File not found: ${resolved}`);
+        throw new Error(`File access error: ${resolved} (${e.message})`);
+    }
+    if (stat.size > MAX_IMAGE_SIZE_BYTES) {
+        throw new Error(`File too large: ${(stat.size / 1048576).toFixed(1)}MB (max: 10MB)`);
+    }
+    const ext = resolved.slice(resolved.lastIndexOf('.')).toLowerCase();
+    if (!ALLOWED_IMAGE_EXTENSIONS.has(ext)) {
+        throw new Error(`Unsupported image format: ${ext} (allowed: ${[...ALLOWED_IMAGE_EXTENSIONS].join(', ')})`);
+    }
+    const contentType = MIME_MAP[ext] || 'application/octet-stream';
+    return { resolved, stat, ext, contentType };
+}
+
+// ========================================
+// Search Variant Generation (ひらがな⇔カタカナ⇔ローマ字)
+// ========================================
+
+const ROMAJI_MAP = {
+    'キャ': 'kya', 'キュ': 'kyu', 'キョ': 'kyo',
+    'シャ': 'sha', 'シュ': 'shu', 'ショ': 'sho',
+    'チャ': 'cha', 'チュ': 'chu', 'チョ': 'cho',
+    'ニャ': 'nya', 'ニュ': 'nyu', 'ニョ': 'nyo',
+    'ヒャ': 'hya', 'ヒュ': 'hyu', 'ヒョ': 'hyo',
+    'ミャ': 'mya', 'ミュ': 'myu', 'ミョ': 'myo',
+    'リャ': 'rya', 'リュ': 'ryu', 'リョ': 'ryo',
+    'ギャ': 'gya', 'ギュ': 'gyu', 'ギョ': 'gyo',
+    'ジャ': 'ja', 'ジュ': 'ju', 'ジョ': 'jo',
+    'ビャ': 'bya', 'ビュ': 'byu', 'ビョ': 'byo',
+    'ピャ': 'pya', 'ピュ': 'pyu', 'ピョ': 'pyo',
+    'ティ': 'ti', 'ディ': 'di', 'ファ': 'fa', 'フィ': 'fi', 'フェ': 'fe', 'フォ': 'fo',
+    'ア': 'a', 'イ': 'i', 'ウ': 'u', 'エ': 'e', 'オ': 'o',
+    'カ': 'ka', 'キ': 'ki', 'ク': 'ku', 'ケ': 'ke', 'コ': 'ko',
+    'サ': 'sa', 'シ': 'shi', 'ス': 'su', 'セ': 'se', 'ソ': 'so',
+    'タ': 'ta', 'チ': 'chi', 'ツ': 'tsu', 'テ': 'te', 'ト': 'to',
+    'ナ': 'na', 'ニ': 'ni', 'ヌ': 'nu', 'ネ': 'ne', 'ノ': 'no',
+    'ハ': 'ha', 'ヒ': 'hi', 'フ': 'fu', 'ヘ': 'he', 'ホ': 'ho',
+    'マ': 'ma', 'ミ': 'mi', 'ム': 'mu', 'メ': 'me', 'モ': 'mo',
+    'ヤ': 'ya', 'ユ': 'yu', 'ヨ': 'yo',
+    'ラ': 'ra', 'リ': 'ri', 'ル': 'ru', 'レ': 're', 'ロ': 'ro',
+    'ワ': 'wa', 'ヲ': 'wo', 'ン': 'n',
+    'ガ': 'ga', 'ギ': 'gi', 'グ': 'gu', 'ゲ': 'ge', 'ゴ': 'go',
+    'ザ': 'za', 'ジ': 'ji', 'ズ': 'zu', 'ゼ': 'ze', 'ゾ': 'zo',
+    'ダ': 'da', 'ヂ': 'di', 'ヅ': 'du', 'デ': 'de', 'ド': 'do',
+    'バ': 'ba', 'ビ': 'bi', 'ブ': 'bu', 'ベ': 'be', 'ボ': 'bo',
+    'パ': 'pa', 'ピ': 'pi', 'プ': 'pu', 'ペ': 'pe', 'ポ': 'po',
+    'ァ': 'a', 'ィ': 'i', 'ゥ': 'u', 'ェ': 'e', 'ォ': 'o',
+    'ヴ': 'v', 'ー': '', 'ッ': '',
+};
+
+function hiraToKata(text) {
+    return text.replace(/[ぁ-ゖ]/g, c => String.fromCharCode(c.charCodeAt(0) + 96));
+}
+
+function kataToHira(text) {
+    return text.replace(/[ァ-ヶ]/g, c => String.fromCharCode(c.charCodeAt(0) - 96));
+}
+
+function kataToRomaji(text) {
+    const result = [];
+    let i = 0;
+    while (i < text.length) {
+        if (i + 1 < text.length && ROMAJI_MAP[text.slice(i, i + 2)]) {
+            result.push(ROMAJI_MAP[text.slice(i, i + 2)]);
+            i += 2;
+        } else if (text[i] === 'ッ' && i + 1 < text.length) {
+            // 促音: 次の子音を重ねる
+            const next2 = (i + 2 < text.length) ? ROMAJI_MAP[text.slice(i + 1, i + 3)] : null;
+            const next1 = ROMAJI_MAP[text[i + 1]];
+            const nextRoma = next2 || next1;
+            if (nextRoma && nextRoma.length > 0) result.push(nextRoma[0]);
+            i += 1;
+        } else if (ROMAJI_MAP[text[i]] !== undefined) {
+            result.push(ROMAJI_MAP[text[i]]);
+            i += 1;
+        } else {
+            result.push(text[i]);
+            i += 1;
+        }
+    }
+    return result.join('');
+}
+
+function toRomaji(text) {
+    const kata = hiraToKata(text);
+    const romaji = kataToRomaji(kata);
+    if (/[一-鿿]/.test(romaji)) return '';
+    return romaji;
+}
+
+function generateSearchVariants(query, strip = [], prefixes = []) {
+    const variants = new Set();
+    let name = query;
+    variants.add(name);
+
+    if (strip && strip.length > 0) {
+        for (const suffix of strip) {
+            if (name.endsWith(suffix)) {
+                name = name.slice(0, -suffix.length);
+                variants.add(name);
+                break;
+            }
+        }
+    }
+
+    const bracketMatch = name.match(/[（(]([^）)]+)[）)]/);
+    if (bracketMatch) {
+        const reading = bracketMatch[1];
+        const base = name.replace(/[（(][^）)]+[）)]/, '').trim();
+        variants.add(base);
+        variants.add(reading);
+        variants.add(hiraToKata(reading));
+        variants.add(kataToHira(reading));
+        const romaji = toRomaji(reading);
+        if (romaji) variants.add(romaji);
+        name = base;
+    } else {
+        variants.add(hiraToKata(name));
+        variants.add(kataToHira(name));
+        const romaji = toRomaji(name);
+        if (romaji) variants.add(romaji);
+    }
+
+    if (prefixes && prefixes.length > 0) {
+        for (const prefix of prefixes) {
+            variants.add(`${prefix}${name}`);
+            if (bracketMatch) {
+                variants.add(`${prefix}${bracketMatch[1]}`);
+            }
+        }
+    }
+
+    variants.delete('');
+    return [...variants];
+}
+
+function flattenFileBirdFolders(folders, result = []) {
+    for (const f of folders) {
+        result.push({ id: f.id, name: f.text || f.title || f.name || '', count: parseInt(f['data-count'], 10) || 0 });
+        if (f.children && f.children.length > 0) {
+            flattenFileBirdFolders(f.children, result);
+        }
+    }
+    return result;
+}
+
 /**
  * 単一クライアントの Editor/Headless 判定
  * @returns {{ mode: 'editor'|'headless'|'error', postId?: number, message?: string, client?: FridayWPClient }}
@@ -679,10 +955,15 @@ async function resolvePostId(rawPostId, client, { skipConflictCheck = false } =
     }
     if (!slug) return { error: '❌ URL からスラッグを抽出できませんでした。' };
 
-    // slug → ID 解決
-    const { data: posts } = await client.listPosts({ slug, status: 'any' });
+    // slug → ID 解決（投稿 + 固定ページを統合検索）
+    const searchResult = await client.searchPosts({ slug, status: 'any', post_type: 'any' });
+    const posts = searchResult.items || [];
     if (!posts || posts.length === 0) {
-        return { error: `❌ スラッグ "${slug}" に一致する投稿が見つかりません。` };
+        return { error: `❌ スラッグ "${slug}" に一致する投稿・固定ページが見つかりません。` };
+    }
+    if (posts.length > 1) {
+        const candidates = posts.map(p => `  [${p.id}] ${p.post_type === 'page' ? '[固定ページ]' : '[投稿]'} ${p.title || '(無題)'} — ${p.link || '-'}`).join('\n');
+        return { error: `❌ スラッグ "${slug}" に複数の候補が見つかりました。postId を数値で指定してください:\n${candidates}` };
     }
     const resolvedId = posts[0].id;
 
@@ -2161,7 +2442,7 @@ const tools = [
     },
     {
         name: "update_post_meta",
-        description: "Update post metadata.",
+        description: "Update post or page metadata.",
         inputSchema: {
             type: "object",
             properties: {
@@ -2170,16 +2451,39 @@ const tools = [
                 title: { type: "string", description: "Title" },
                 status: { type: "string", enum: ["publish", "draft", "pending", "private"], description: "Status" },
                 slug: { type: "string", description: "Slug (URL)" },
-                categories: { type: "array", items: { type: "number" }, description: "Category IDs" },
-                tags: { type: "array", items: { type: "number" }, description: "Tag IDs" },
+                categories: { type: "array", items: { type: "number" }, description: "Category IDs (posts only)" },
+                tags: { type: "array", items: { type: "number" }, description: "Tag IDs (posts only)" },
+                parent: { type: "number", description: "Parent page ID (pages only, 0 to remove)" },
                 excerpt: { type: "string", description: "Excerpt" },
                 featured_media: { type: "number", description: "Featured image ID (0 to remove)" },
             },
         },
     },
+    {
+        name: "create_post",
+        description: "Create a new WordPress post or page (draft by default). Returns post ID and editor URL.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title:          { type: "string", description: "Post title" },
+                post_type:      { type: "string", enum: ["post", "page"], description: "Content type (default: post)" },
+                slug:           { type: "string", description: "URL slug" },
+                status:         { type: "string", enum: ["publish", "draft", "pending", "private"], description: "Status (default: draft)" },
+                categories:     { type: "array", items: { type: "number" }, description: "Category IDs (posts only)" },
+                tags:           { type: "array", items: { type: "number" }, description: "Tag IDs (posts only)" },
+                parent:         { type: "number", description: "Parent page ID (pages only)" },
+                featured_media: { type: "number", description: "Featured image media ID" },
+                excerpt:        { type: "string", description: "Excerpt" },
+                content:        { type: "string", description: "HTML content (exclusive with filePath)" },
+                filePath:       { type: "string", description: "Local file path (.md or .html, exclusive with content)" },
+                site:           siteParam,
+            },
+            required: ["title"],
+        },
+    },
     {
         name: "list_posts",
-        description: "Search posts. Use slug for exact match, search for keyword. Mutually exclusive.",
+        description: "Search posts and pages. Use slug for exact match, search for keyword. Mutually exclusive.",
         inputSchema: {
             type: "object",
             properties: {
@@ -2187,6 +2491,7 @@ const tools = [
                 slug: { type: "string", description: "Slug for exact match (exclusive with search)" },
                 search: { type: "string", description: "Keyword (exclusive with slug)" },
                 status: { type: "string", enum: ["publish", "draft", "pending", "private", "any"], description: "Status filter (default: publish)" },
+                post_type: { type: "string", enum: ["post", "page", "any"], description: "Filter by type: post, page, or any (default: any)" },
                 categories: { type: "array", items: { type: "number" }, description: "Category IDs" },
                 tags: { type: "array", items: { type: "number" }, description: "Tag IDs" },
                 per_page: { type: "integer", description: "Per page (1-100)", minimum: 1, maximum: 100 },
@@ -2196,6 +2501,101 @@ const tools = [
             },
         },
     },
+    {
+        name: "list_blog_parts",
+        description: "List or search blog parts (reusable blocks). When partsId is specified, returns posts/pages that directly use that blog parts. SWELL theme only.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                partsId: { type: "integer", description: "Blog parts ID. When specified, returns posts/pages that directly use this blog parts instead of listing blog parts." },
+                search: { type: "string", description: "Keyword search (ignored when partsId is set)" },
+                status: { type: "string", enum: ["publish", "draft", "private", "any"], description: "Status filter (default: publish, ignored when partsId is set)" },
+                per_page: { type: "integer", description: "Per page (1-100)", minimum: 1, maximum: 100 },
+                page: { type: "integer", description: "Page number", minimum: 1 },
+            },
+        },
+    },
+    {
+        name: "get_blog_parts",
+        description: "Get blog parts structure and blocks by partsId. Opens a blog parts post for viewing/editing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                partsId: { type: "integer", description: "Blog parts ID (required)" },
+                site: siteParam,
+                full: { type: "boolean", description: "Full block data" },
+                section: { type: "string", description: "Zoom into section" },
+                blockType: { type: "string", description: "Filter by block type" },
+                contains: { type: "string", description: "Text search" },
+            },
+            required: ["partsId"],
+        },
+    },
+    {
+        name: "create_blog_parts",
+        description: "Create a new blog parts (reusable block). SWELL theme only. Returns partsId and editor URL. To insert into an article, use insert_blog_parts with the returned partsId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title:     { type: "string", description: "Blog parts title" },
+                status:    { type: "string", enum: ["publish", "draft", "pending", "private"], description: "Status (default: publish)" },
+                slug:      { type: "string", description: "URL slug" },
+                content:   { type: "string", description: "HTML content (exclusive with filePath)" },
+                filePath:  { type: "string", description: "Local file path (.md or .html, exclusive with content)" },
+                parts_use: { type: "array", items: { type: "number" }, description: "parts_use taxonomy term IDs (SWELL usage category)" },
+                site:      siteParam,
+            },
+            required: ["title"],
+        },
+    },
+    {
+        name: "update_blog_parts",
+        description: "Update blog parts blocks. Same as update_blocks but for blog parts posts. Headless only.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                partsId: { type: "integer", description: "Blog parts ID (required)" },
+                site: siteParam,
+                snapshotId: { type: "string", description: "Snapshot ID from get_blog_parts." },
+                ref: { type: "string", description: "Block ref from snapshot." },
+                refs: { type: "array", items: { type: "string" }, description: "Multiple block refs." },
+                expectedRevision: { type: "string", description: "Revision check." },
+                newHTML: { type: "string", description: "New block HTML." },
+                replacements: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            old: { type: "string" },
+                            new: { type: "string" },
+                            regex: { type: "boolean" },
+                        },
+                        required: ["old", "new"],
+                    },
+                    description: "Text replacements.",
+                },
+            },
+            required: ["partsId"],
+        },
+    },
+    {
+        name: "insert_blog_parts",
+        description: "Insert a blog parts block into an article. Builds the correct block HTML automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                partsId:   { type: "integer", description: "Blog parts ID (required)" },
+                postId:    postIdParam,
+                site:      siteParam,
+                snapshotId: { type: "string", description: "Snapshot ID (from get_article_structure or any write response). Required when using beforeRef/afterRef. Omit to append to end." },
+                expectedRevision: { type: "string", description: "Revision from snapshot. Rejects if structure changed." },
+                beforeRef: { type: "string", description: "Insert before this ref." },
+                afterRef:  { type: "string", description: "Insert after this ref." },
+            },
+            required: ["partsId"],
+        },
+    },
     {
         name: "list_taxonomies",
         description: "List categories or tags.",
@@ -2244,7 +2644,7 @@ const tools = [
     },
     {
         name: "get_block_html",
-        description: "Get block HTML. Use before newHTML to safely edit custom/theme blocks.",
+        description: "Get block HTML. Use before newHTML to safely edit custom/theme blocks. Blog parts (loos/blog-parts) are auto-expanded to show inner content. To edit blog parts content, use update_blog_parts.",
         inputSchema: {
             type: "object",
             properties: {
@@ -2418,6 +2818,46 @@ const tools = [
             },
         },
     },
+    {
+        name: "upload_media",
+        description: "Upload image to WordPress media library. Returns media ID, URL, dimensions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                filePath: { type: "string", description: "Absolute path to image file on local machine" },
+                name: { type: "string", description: "New filename (without extension, ASCII/hyphens recommended)" },
+                alt: { type: "string", description: "Alt text and title (Japanese OK)" },
+                title: { type: "string", description: "Title (defaults to alt if omitted)" },
+            },
+            required: ["filePath", "name", "alt"],
+        },
+    },
+    {
+        name: "search_media",
+        description: "Search WordPress media library. Auto-generates hiragana/katakana/romaji variants for broader matching.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                query: { type: "string", description: "Search keyword" },
+                folder: { type: "string", description: "FileBird folder name (partial match). Filters media to this folder." },
+                strip: { type: "array", items: { type: "string" }, description: "Suffixes to strip (e.g. ['先生', 'さん'])" },
+                prefix: { type: "array", items: { type: "string" }, description: "Prefixes to add (e.g. ['エキサイト-'])" },
+                per_page: { type: "integer", description: "Results per variant (1-20, default: 10)", minimum: 1, maximum: 20 },
+            },
+        },
+    },
+    {
+        name: "list_media_folders",
+        description: "List FileBird media folders. Returns folder names, IDs, and file counts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+            },
+        },
+    },
     {
         name: "list_connections",
         description: "List connections.",
@@ -2449,6 +2889,39 @@ const tools = [
             required: ["content"],
         },
     },
+    {
+        name: "search_asp_link",
+        description: "Search registered ASP affiliate links. Search by title, slug, or keyword across title and asp fields.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                search: { type: "string", description: "Keyword search (title, asp_id, asp_name)" },
+                slug: { type: "string", description: "Exact post slug match (exclusive with search)" },
+                per_page: { type: "integer", minimum: 1, maximum: 100, description: "Results per page (default: 20)" },
+                page: { type: "integer", minimum: 1, description: "Page number (default: 1)" },
+            },
+        },
+    },
+    {
+        name: "register_asp_link",
+        description: "Register a new ASP affiliate link. Creates a jump post with ASP metadata.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                site: siteParam,
+                title: { type: "string", description: "Display name (e.g. 'モコム')" },
+                slug: { type: "string", description: "WordPress post slug for URL (e.g. 'mocom')" },
+                asp_id: { type: "string", description: "ASP案件ID — data-id attribute used by JSLinkHelper (defaults to slug if omitted)" },
+                asp_name: { type: "string", description: "案件名 (defaults to title if omitted)" },
+                asp_url: { type: "string", description: "ASP affiliate URL (required)" },
+                asp_url_sp: { type: "string", description: "ASP URL (B) for A/B testing (optional)" },
+                direct_url: { type: "string", description: "Direct URL bypassing ASP (optional)" },
+                permalink: { type: "string", description: "WordPress permalink slug (defaults to asp_id, then slug if omitted)" },
+            },
+            required: ["title", "slug", "asp_url"],
+        },
+    },
 ];
 
 // ツールリストのハンドラ
@@ -2576,7 +3049,7 @@ async function handleUpdateBlocksTool(args, toolName) {
             return { content: [{ type: "text", text: "❌ filePath は attributeUpdates と併用できません。" }], isError: true };
         }
         try {
-            newHTML = readHTMLFromFile(args.filePath).html;
+            newHTML = await resolveFileToBlockHTML(args.filePath);
         } catch (e) {
             return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
         }
@@ -2846,7 +3319,7 @@ async function handleUpdateBlocksTool(args, toolName) {
 }
 
 // ツール実行のハンドラ
-const _WRITE_TOOLS = new Set(['update_blocks', 'delete_block', 'move_block', 'duplicate_block', 'insert_block', 'table_operations']);
+const _WRITE_TOOLS = new Set(['update_blocks', 'delete_block', 'move_block', 'duplicate_block', 'insert_block', 'table_operations', 'update_blog_parts', 'insert_blog_parts']);
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const _toolLogStart = Date.now();
@@ -2967,10 +3440,49 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const endIdx = (limit && limit > 0) ? startIdx + limit : blocks.length;
                     blocks = blocks.slice(startIdx, endIdx);
 
+                    // エディタモード時、ブロパの展開情報をヘッドレス API で補完
+                    if (mode === 'editor' && client) {
+                        for (const b of blocks) {
+                            if (b.type === 'loos/blog-parts' && !b.blogParts) {
+                                const pid = parseInt(b.attributes?.partsID, 10);
+                                if (pid > 0) {
+                                    try {
+                                        const bpBlocks = await client.headlessGetBlocks(pid);
+                                        const meta = await client.headlessGetMeta(pid);
+                                        b.blogParts = {
+                                            partsId: pid,
+                                            partsTitle: meta?.title || '',
+                                            blocks: (bpBlocks?.blocks || []).map(bl => ({ type: bl.type, depth: bl.depth || 0 })),
+                                        };
+                                    } catch (_) {
+                                        b.blogPartsError = 'not_found';
+                                    }
+                                }
+                            }
+                        }
+                    }
+
                     const blockList = blocks.map(b => {
                         const attrPreview = JSON.stringify(b.attributes || {}).slice(0, 200);
                         const t = formatTreeLine(b);
-                        return `${t.indent}[${b.index}${_refTag(b.index)}] ${t.marker}${b.type}${t.childInfo} - ${b.section || "(記事冒頭)"} ${t.depthInfo}\n${t.indent}  ${attrPreview}${attrPreview.length >= 200 ? '...' : ''}`;
+                        let line = `${t.indent}[${b.index}${_refTag(b.index)}] ${t.marker}${b.type}${t.childInfo} - ${b.section || "(記事冒頭)"} ${t.depthInfo}\n${t.indent}  ${attrPreview}${attrPreview.length >= 200 ? '...' : ''}`;
+
+                        // ブロパ展開表示（読み取り専用、ref なし）
+                        if (b.blogParts) {
+                            line += `\n${t.indent}  📦 "${b.blogParts.partsTitle}" [ID:${b.blogParts.partsId}]`;
+                            const innerBlocks = b.blogParts.blocks || [];
+                            for (const inner of innerBlocks.slice(0, 10)) {
+                                const innerIndent = '  '.repeat((inner.depth || 0) + 1);
+                                line += `\n${t.indent}  ${innerIndent}└ ${inner.type}`;
+                            }
+                            if (innerBlocks.length > 10) {
+                                line += `\n${t.indent}    ... 他 ${innerBlocks.length - 10} ブロック`;
+                            }
+                        } else if (b.blogPartsError) {
+                            line += `\n${t.indent}  ⚠️ ブログパーツ展開失敗: ${b.blogPartsError}`;
+                        }
+
+                        return line;
                     }).join("\n\n");
 
                     let paginationInfo = '';
@@ -3313,6 +3825,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     output += `${indent}${prefix} ${heading.text} (H${heading.level}, index:${heading.index}${_refTag(heading.index)})\n`;
                 }
 
+                // ブログパーツ一覧
+                if (state.blockSummary && state.blockSummary['loos/blog-parts']) {
+                    const bpEntries = state.blockSummary['loos/blog-parts'].blocks || [];
+                    const bpItems = [];
+                    for (const bp of bpEntries) {
+                        const pid = bp.partsId || (bp.attributes?.partsID ? parseInt(bp.attributes.partsID, 10) : 0);
+                        if (!pid) continue;
+                        let title = bp.partsTitle || '';
+                        // エディタモード等でタイトルが空の場合、ヘッドレス API で補完
+                        if (!title && client) {
+                            try {
+                                const meta = await client.headlessGetMeta(pid);
+                                title = meta?.title || '';
+                            } catch (_) {}
+                        }
+                        bpItems.push({ index: bp.index, partsId: pid, title });
+                    }
+                    if (bpItems.length > 0) {
+                        output += `\nブログパーツ:\n`;
+                        for (const bp of bpItems) {
+                            output += `  [${bp.index}] 📦 "${bp.title || '(不明)'}" [ID:${bp.partsId}]\n`;
+                        }
+                        output += `  ※ 中身の確認は get_blog_parts(partsId) を使用\n`;
+                    }
+                }
+
                 return {
                     content: [{ type: "text", text: output + _snapshotLine + _modeTag_gas }],
                 };
@@ -3751,21 +4289,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const statusInfo = mode === 'editor'
                     ? `モード: Editor (接続中)`
                     : `モード: Headless (postId: ${postId})`;
-                const text = [
-                    `📄 投稿メタ情報`,
+                const isPage = m.post_type === 'page';
+                const typeLabel = isPage ? '📄 固定ページメタ情報' : '📄 投稿メタ情報';
+                const lines = [
+                    typeLabel,
                     ``,
                     statusInfo,
                     `ID: ${m.id}`,
+                    `タイプ: ${m.post_type || 'post'}`,
                     `タイトル: ${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');
+                ];
+                if (isPage) {
+                    lines.push(`親ページ: ${m.parent || 'なし'}`);
+                } else {
+                    lines.push(`カテゴリ: ${JSON.stringify(m.categories)}`);
+                    lines.push(`タグ: ${JSON.stringify(m.tags)}`);
+                }
+                lines.push(`アイキャッチ: ${m.featuredImage || 'なし'}`);
+                lines.push(`抜粋: ${m.excerpt || 'なし'}`);
+                lines.push(`更新日: ${m.modified}`);
+                const text = lines.join('\n');
                 return { content: [{ type: "text", text }] };
             }
 
@@ -3791,6 +4337,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 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.parent !== undefined) updateData.parent = args.parent;
                 if (args.excerpt !== undefined) updateData.excerpt = args.excerpt;
                 if (args.featured_media !== undefined) updateData.featured_media = args.featured_media;
 
@@ -3812,6 +4359,77 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: updateText }] };
             }
 
+            case "create_post": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const title = args?.title?.trim();
+                if (!title) {
+                    return { content: [{ type: "text", text: "❌ title は必須です。" }], isError: true };
+                }
+
+                let content = args?.content;
+                const filePath = args?.filePath;
+
+                if (content !== undefined && filePath !== undefined) {
+                    return { content: [{ type: "text", text: "❌ content と filePath は同時に指定できません。どちらか一方を指定してください。" }], isError: true };
+                }
+
+                if (filePath) {
+                    try {
+                        content = await resolveFileToBlockHTML(filePath);
+                    } catch (e) {
+                        return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                    }
+                }
+
+                const postType = args?.post_type || 'post';
+
+                if (postType === 'page' && (args?.categories !== undefined || args?.tags !== undefined)) {
+                    return { content: [{ type: "text", text: "❌ 固定ページにカテゴリ・タグは設定できません。" }], isError: true };
+                }
+
+                const postData = {
+                    title,
+                    status: args?.status || 'draft',
+                    post_type: postType,
+                };
+                if (args?.slug !== undefined)           postData.slug = args.slug;
+                if (postType === 'page') {
+                    if (args?.parent !== undefined)     postData.parent = args.parent;
+                } else {
+                    if (args?.categories !== undefined) postData.categories = args.categories;
+                    if (args?.tags !== undefined)       postData.tags = args.tags;
+                }
+                if (args?.excerpt !== undefined)        postData.excerpt = args.excerpt;
+                if (args?.featured_media !== undefined) postData.featured_media = args.featured_media;
+                if (content && content.trim())          postData.content = content;
+
+                const typeLabel = postType === 'page' ? '固定ページ' : '投稿';
+
+                try {
+                    const created = await client.createPost(postData);
+                    const postId = created.id;
+                    const editUrl = `${client.wpUrl.replace(/\/$/, '')}/wp-admin/post.php?post=${postId}&action=edit`;
+                    const resultText = [
+                        `✅ ${typeLabel}を作成しました`,
+                        ``,
+                        `  ID: ${postId}`,
+                        `  タイプ: ${postType}`,
+                        `  タイトル: ${created.title?.raw || title}`,
+                        `  ステータス: ${created.status}`,
+                        `  編集URL: ${editUrl}`,
+                    ].join('\n');
+                    return { content: [{ type: "text", text: resultText }] };
+                } catch (e) {
+                    return errorResponse(name, `${typeLabel}作成に失敗しました: ${e.message}`, args?.site);
+                }
+            }
+
             case "list_posts": {
                 let client;
                 try {
@@ -3829,26 +4447,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     return { content: [{ type: "text", text: "❌ slug と search は同時に指定できません。slug（完全一致）または search（キーワード検索）のいずれかを使用してください。" }], isError: true };
                 }
 
-                // listArgs を構築（slug 指定時: status 未指定なら 'any' に自動設定）
-                const listArgs = { ...(args || {}), slug, search };
+                const postType = args?.post_type || 'any';
+                const listArgs = { ...(args || {}), slug, search, post_type: postType };
                 if (slug && !listArgs.status) {
                     listArgs.status = 'any';
                 }
 
-                const { data: posts, total, totalPages } = await client.listPosts(listArgs);
+                const result = await client.searchPosts(listArgs);
+                const posts = result.items || [];
+                const total = result.total || 0;
+                const totalPages = result.total_pages || 0;
 
-                if (!posts || posts.length === 0) {
-                    return { content: [{ type: "text", text: "📋 該当する投稿はありません。" }] };
+                if (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` +
+                    const typeLabel = p.post_type === 'page' ? '[固定ページ]' : '[投稿]';
+                    return `  [${p.id}] ${typeLabel} ${p.title || '(無題)'}\n` +
                            `    ステータス: ${p.status} | 更新: ${p.modified?.split('T')[0] || '-'}\n` +
                            `    URL: ${p.link || '-'}`;
                 }).join('\n\n');
 
-                let listText = `📋 投稿一覧 (${posts.length}件 / 全${total}件)\n\n${list}`;
+                let listText = `📋 一覧 (${posts.length}件 / 全${total}件)\n\n${list}`;
                 if (totalPages > 1) {
                     listText += `\n\n📄 ページ: ${currentPage} / ${totalPages}`;
                     if (currentPage < totalPages) {
@@ -3859,6 +4481,269 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: listText }] };
             }
 
+            case "create_blog_parts": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const title = args?.title?.trim();
+                if (!title) {
+                    return { content: [{ type: "text", text: "❌ title は必須です。" }], isError: true };
+                }
+
+                let content = args?.content;
+                const filePath = args?.filePath;
+
+                if (content !== undefined && filePath !== undefined) {
+                    return { content: [{ type: "text", text: "❌ content と filePath は同時に指定できません。" }], isError: true };
+                }
+
+                if (filePath) {
+                    try {
+                        content = await resolveFileToBlockHTML(filePath);
+                    } catch (e) {
+                        return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                    }
+                }
+
+                const postData = {
+                    title,
+                    status: args?.status || 'publish',
+                    post_type: 'blog_parts',
+                };
+                if (args?.slug !== undefined)      postData.slug = args.slug;
+                if (args?.parts_use !== undefined) postData.parts_use = args.parts_use;
+                if (content && content.trim())     postData.content = content;
+
+                try {
+                    const created = await client.createPost(postData);
+                    const postId = created.id;
+                    const editUrl = `${client.wpUrl.replace(/\/$/, '')}/wp-admin/post.php?post=${postId}&action=edit`;
+                    const resultText = [
+                        `✅ ブログパーツを作成しました`,
+                        ``,
+                        `  ID: ${postId}`,
+                        `  タイトル: ${created.title?.raw || title}`,
+                        `  ステータス: ${created.status}`,
+                        `  編集URL: ${editUrl}`,
+                    ].join('\n');
+                    return { content: [{ type: "text", text: resultText }] };
+                } catch (e) {
+                    return errorResponse(name, `ブログパーツ作成に失敗しました: ${e.message}`, args?.site);
+                }
+            }
+
+            case "list_blog_parts": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const bpResult = await client.searchBlogParts(args || {});
+
+                if (args?.partsId) {
+                    const usedBy = bpResult.usedBy || [];
+                    if (usedBy.length === 0) {
+                        return { content: [{ type: "text", text: `📋 ブログパーツ [${bpResult.partsId}] "${bpResult.partsTitle}" はどの記事でも使用されていません。` }] };
+                    }
+                    const usageList = usedBy.map(p =>
+                        `  [${p.postId}] ${p.title || '(無題)'}\n    ステータス: ${p.status} | 更新: ${p.modified || '-'}`
+                    ).join('\n\n');
+                    let usageText = `📋 ブログパーツ [${bpResult.partsId}] "${bpResult.partsTitle}" の直接使用箇所 (${usedBy.length}件 / 全${bpResult.total}件)\n\n${usageList}`;
+                    if (bpResult.total_pages > 1) {
+                        const pg = args?.page || 1;
+                        usageText += `\n\n📄 ページ: ${pg} / ${bpResult.total_pages}`;
+                        if (pg < bpResult.total_pages) usageText += ` (次: page=${pg + 1})`;
+                    }
+                    return { content: [{ type: "text", text: usageText }] };
+                }
+
+                const bpParts = bpResult.items || [];
+                const bpTotal = bpResult.total || 0;
+                const bpTotalPages = bpResult.total_pages || 0;
+
+                if (bpParts.length === 0) {
+                    return { content: [{ type: "text", text: "📋 該当するブログパーツはありません。" }] };
+                }
+
+                const bpPage = args?.page || 1;
+                const bpList = bpParts.map(p => {
+                    return `  [${p.id}] ${p.title || '(無題)'}\n    ステータス: ${p.status} | 更新: ${p.modified || '-'}`;
+                }).join('\n\n');
+
+                let bpText = `📋 ブログパーツ一覧 (${bpParts.length}件 / 全${bpTotal}件)\n\n${bpList}`;
+                if (bpTotalPages > 1) {
+                    bpText += `\n\n📄 ページ: ${bpPage} / ${bpTotalPages}`;
+                    if (bpPage < bpTotalPages) {
+                        bpText += ` (次: page=${bpPage + 1})`;
+                    }
+                }
+                return { content: [{ type: "text", text: bpText }] };
+            }
+
+            case "get_blog_parts": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const bpPartsId = args?.partsId;
+                if (!bpPartsId) {
+                    return { content: [{ type: "text", text: "❌ partsId は必須です" }], isError: true };
+                }
+
+                const siteName = args?.site || registry.defaultName();
+                const { full: bpFull, contains: bpContains, section: bpSection, blockType: bpBlockType } = (args || {});
+
+                let bpState;
+                try {
+                    bpState = await client.headlessGetStructure(bpPartsId);
+                    if (bpFull || bpContains || bpSection || bpBlockType) {
+                        const blocksData = await client.headlessGetBlocks(bpPartsId);
+                        bpState.allBlocks = blocksData.blocks;
+                    }
+                } catch (e) {
+                    const formatted = formatHeadlessConflictError(e);
+                    if (formatted) return formatted;
+                    throw e;
+                }
+
+                // snapshot 作成（編集用 ref を付与）
+                let _bpRefTag = (_idx) => '';
+                let _bpSnapshotLine = '';
+                const bpBlocks = bpState.allBlocks || [];
+                if (bpBlocks.length > 0) {
+                    const _bpSnapshotId = generateSnapshotId();
+                    const _bpRevision = `rev_${Date.now().toString(36)}`;
+                    const _bpSnapshotBlocks = bpBlocks.map((b, i) => ({ ...b, ref: `r${i}` }));
+                    snapshotCache.set({
+                        snapshotId: _bpSnapshotId, postId: bpPartsId, mode: 'headless',
+                        sessionId: null, siteName,
+                        createdAt: Date.now(), revision: _bpRevision,
+                        blocks: _bpSnapshotBlocks, displayMode: bpFull ? 'full' : 'default',
+                    });
+                    const _bpRefMap = new Map(_bpSnapshotBlocks.map(b => [b.index, b.ref]));
+                    _bpRefTag = (idx) => { const r = _bpRefMap.get(idx); return r ? `|${r}` : ''; };
+                    _bpSnapshotLine = `\n[snapshot:${_bpSnapshotId} rev:${_bpRevision}]`;
+                }
+
+                if ((bpFull || bpContains || bpSection || bpBlockType) && bpBlocks.length > 0) {
+                    let filteredBlocks = bpBlocks;
+                    if (bpBlockType) filteredBlocks = filteredBlocks.filter(b => b.type === bpBlockType);
+                    if (bpContains) filteredBlocks = filteredBlocks.filter(b => (b.html || '').includes(bpContains));
+
+                    const bpBlockList = filteredBlocks.map(b => {
+                        const indent = '  '.repeat((b.depth || 0) + 1);
+                        const hasChildren = b.isContainer ? ` ▼ [${b.childCount}子]` : '';
+                        return `${indent}[${b.index}${_bpRefTag(b.index)}] ${b.type}${hasChildren}`;
+                    }).join('\n');
+
+                    return { content: [{ type: "text", text: `📦 ブログパーツ [${bpPartsId}]\n\n全ブロック (${filteredBlocks.length}件):\n\n${bpBlockList}${_bpSnapshotLine}\n[DEBUG] mode=headless` }] };
+                }
+
+                // デフォルト: 見出し + サマリー
+                const bpHeadings = (bpState.headings || [])
+                    .map(h => `  ${"#".repeat(h.level)} ${h.text} (index:${h.index})`)
+                    .join("\n");
+                const bpSummaryLines = Object.entries(bpState.blockSummary || {})
+                    .map(([type, data]) => `  ${type}: ${data.count}個`)
+                    .join("\n");
+
+                let bpOutText = `📦 ブログパーツ [${bpPartsId}]\n\n`;
+                if (bpHeadings) bpOutText += `見出し構造:\n${bpHeadings}\n\n`;
+                bpOutText += `ブロック概要:\n${bpSummaryLines}`;
+                bpOutText += _bpSnapshotLine;
+                bpOutText += '\n[DEBUG] mode=headless';
+
+                return { content: [{ type: "text", text: bpOutText }] };
+            }
+
+            case "update_blog_parts": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const ubpPartsId = args?.partsId;
+                if (!ubpPartsId) {
+                    return { content: [{ type: "text", text: "❌ partsId は必須です" }], isError: true };
+                }
+
+                const siteName = args?.site || registry.defaultName();
+
+                // ref/refs → index/indices 解決
+                const ubpParams = { ...args };
+                delete ubpParams.partsId;
+                delete ubpParams.site;
+
+                if (ubpParams.snapshotId && (ubpParams.ref || ubpParams.refs)) {
+                    const snap = snapshotCache.get(ubpParams.snapshotId);
+                    if (!snap) {
+                        return { content: [{ type: "text", text: "❌ snapshotId が無効または期限切れです。get_blog_parts で再取得してください。" }], isError: true };
+                    }
+                    if (snap.postId !== ubpPartsId) {
+                        return { content: [{ type: "text", text: `❌ snapshot の postId (${snap.postId}) と partsId (${ubpPartsId}) が一致しません。` }], isError: true };
+                    }
+
+                    if (ubpParams.ref) {
+                        const refBlock = snap.blocks.find(b => b.ref === ubpParams.ref);
+                        if (!refBlock) {
+                            return { content: [{ type: "text", text: `❌ ref "${ubpParams.ref}" が snapshot 内に見つかりません。` }], isError: true };
+                        }
+                        ubpParams.index = refBlock.index;
+                        delete ubpParams.ref;
+                    }
+                    if (ubpParams.refs) {
+                        const indices = [];
+                        for (const r of ubpParams.refs) {
+                            const refBlock = snap.blocks.find(b => b.ref === r);
+                            if (!refBlock) {
+                                return { content: [{ type: "text", text: `❌ ref "${r}" が snapshot 内に見つかり���せん。` }], isError: true };
+                            }
+                            indices.push(refBlock.index);
+                        }
+                        ubpParams.indices = indices;
+                        delete ubpParams.refs;
+                    }
+                    delete ubpParams.snapshotId;
+                }
+                delete ubpParams.expectedRevision;
+
+                try {
+                    const ubpResult = await client.headlessUpdate(ubpPartsId, ubpParams);
+
+                    // 新 snapshot 生成
+                    let ubpSnapshotLine = '';
+                    if (ubpResult.blocks && ubpResult.blocks.length > 0) {
+                        const _ubpSnapId = generateSnapshotId();
+                        const _ubpRev = `rev_${Date.now().toString(36)}`;
+                        const _ubpSnapBlocks = ubpResult.blocks.map((b, i) => ({ ...b, ref: `r${i}` }));
+                        snapshotCache.set({
+                            snapshotId: _ubpSnapId, postId: ubpPartsId, mode: 'headless',
+                            sessionId: null, siteName,
+                            createdAt: Date.now(), revision: _ubpRev,
+                            blocks: _ubpSnapBlocks, displayMode: 'full',
+                        });
+                        ubpSnapshotLine = `\n[snapshot:${_ubpSnapId} rev:${_ubpRev}]`;
+                    }
+
+                    return { content: [{ type: "text", text: `✅ ブログパーツ [${ubpPartsId}] を更新しました。${ubpSnapshotLine}` }] };
+                } catch (e) {
+                    const formatted = formatHeadlessConflictError(e);
+                    if (formatted) return formatted;
+                    throw e;
+                }
+            }
+
             case "list_taxonomies": {
                 let client;
                 try {
@@ -3897,6 +4782,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text }] };
             }
 
+            case "insert_blog_parts": {
+                if (!args?.partsId) {
+                    return { content: [{ type: "text", text: "❌ partsId は必須です。" }], isError: true };
+                }
+                args.rawHTML = `<!-- wp:loos/blog-parts {"partsID":"${args.partsId}"} /-->`;
+                // insert_block に fallthrough
+            }
+
             case "insert_block": {
                 let { rawHTML, filePath } = (args || {});
 
@@ -3912,7 +4805,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
                 // filePath → rawHTML 解決
                 if (filePath) {
-                    try { rawHTML = readHTMLFromFile(filePath).html; }
+                    try { rawHTML = await resolveFileToBlockHTML(filePath); }
                     catch (e) { return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true }; }
                 }
                 if (!rawHTML) {
@@ -4025,10 +4918,36 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     blocks = result.blocks || [];
                 }
 
+                // エディタモード時、ブログパーツの展開を補完
+                if (mode === 'editor' && client) {
+                    for (const b of blocks) {
+                        if (b.type === 'loos/blog-parts' && !b.blogParts) {
+                            const pid = parseInt(b.html?.match(/partsID["\s:]+["']?(\d+)/)?.[1], 10);
+                            if (pid > 0) {
+                                try {
+                                    const bpResult = await client.headlessGetBlockHtml(pid, {});
+                                    b.blogParts = {
+                                        partsId: pid,
+                                        blocks: bpResult?.blocks || [],
+                                    };
+                                } catch (_) {}
+                            }
+                        }
+                    }
+                }
+
                 const _modeTag = process.env.FRIDAY_DEBUG === '1' ? `\n[DEBUG] mode=${mode}` : '';
                 let text = `📦 ブロックHTML取得 (${blocks.length}件)\n`;
                 for (const b of blocks) {
-                    text += `\n[${b.index}] ${b.type}\n${b.html}\n`;
+                    text += `\n[${b.index}] ${b.type}\n`;
+                    if (b.blogParts && b.blogParts.blocks) {
+                        for (const inner of b.blogParts.blocks) {
+                            if ((inner.depth || 0) > 0) continue;
+                            text += `${inner.html}\n`;
+                        }
+                    } else {
+                        text += `${b.html}\n`;
+                    }
                 }
                 text += _modeTag;
                 return { content: [{ type: "text", text }] };
@@ -4289,8 +5208,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
                 let url;
                 if (target === 'front') {
-                    const postData = await client.wpCoreRequest(`/wp/v2/posts/${postId}?_fields=link`);
-                    url = postData.link;
+                    try {
+                        const meta = await client.headlessGetMeta(postId);
+                        url = meta.link;
+                    } catch {
+                        try {
+                            const postData = await client.wpCoreRequest(`/wp/v2/posts/${postId}?_fields=link`);
+                            url = postData.link;
+                        } catch {
+                            const pageData = await client.wpCoreRequest(`/wp/v2/pages/${postId}?_fields=link`);
+                            url = pageData.link;
+                        }
+                    }
                 } else {
                     url = `${client.wpUrl.replace(/\/$/, '')}/wp-admin/post.php?post=${postId}&action=edit`;
                 }
@@ -4335,6 +5264,178 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
             }
 
+            case "upload_media": {
+                const siteName = args?.site || 'default';
+                let client;
+                try { client = registry.get(siteName); }
+                catch (e) { return errorResponse("upload_media", e.message, siteName); }
+
+                if (!args?.filePath) return errorResponse("upload_media", "filePath is required", siteName);
+                if (!args?.name) return errorResponse("upload_media", "name is required", siteName);
+                if (!args?.alt) return errorResponse("upload_media", "alt is required", siteName);
+
+                let fileInfo;
+                try { fileInfo = validateImageFile(args.filePath); }
+                catch (e) { return errorResponse("upload_media", e.message, siteName); }
+
+                const uploadFilename = `${args.name}${fileInfo.ext}`;
+                const fileBuffer = readFileSync(fileInfo.resolved);
+
+                let media;
+                try {
+                    media = await client.uploadMedia(fileBuffer, uploadFilename, fileInfo.contentType);
+                } catch (e) {
+                    return errorResponse("upload_media", `Upload failed: ${e.message}`, siteName);
+                }
+
+                const titleText = args?.title || args.alt;
+                try {
+                    await client.updateMediaMeta(media.id, { title: titleText, alt_text: args.alt });
+                } catch (e) {
+                    // meta 更新失敗は警告のみ（アップロード自体は成功）
+                }
+
+                const url = media.source_url || '';
+                const width = media.media_details?.width || null;
+                const height = media.media_details?.height || null;
+                const text = `✅ Uploaded: ID=${media.id}\n` +
+                    `   Title: ${titleText}\n` +
+                    `   Alt: ${args.alt}\n` +
+                    `   URL: ${url}\n` +
+                    (width && height ? `   Size: ${width}x${height}\n` : '') +
+                    `   Filename: ${uploadFilename}`;
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "search_media": {
+                const siteName = args?.site || 'default';
+                let client;
+                try { client = registry.get(siteName); }
+                catch (e) { return errorResponse("search_media", e.message, siteName); }
+
+                if (!args?.query && !args?.folder) return errorResponse("search_media", "query または folder のどちらかは必須です", siteName);
+
+                const perPage = args?.per_page || 10;
+
+                // --- FileBird folder filtering ---
+                let folderIncludeIds = null;
+                let folderInfo = '';
+                if (args?.folder) {
+                    if (!client.filebirdToken) {
+                        return errorResponse("search_media", "FileBird APIキーが未設定です。connections.json に filebirdToken を追加してください", siteName);
+                    }
+                    const folders = await client.getFileBirdFolders();
+                    if (!folders) {
+                        return errorResponse("search_media", "FileBird API へのアクセスに失敗しました", siteName);
+                    }
+                    const flat = flattenFileBirdFolders(folders);
+                    const matched = flat.filter(f => f.name.includes(args.folder));
+                    if (matched.length === 0) {
+                        return errorResponse("search_media", `フォルダ "${args.folder}" が見つかりません。\n利用可能: ${flat.map(f => f.name).join(', ')}`, siteName);
+                    }
+                    if (matched.length > 1) {
+                        let text = `📁 "${args.folder}" に複数のフォルダがマッチしました。絞り込んでください:\n\n`;
+                        for (const f of matched) {
+                            text += `  [ID: ${f.id}] ${f.name} (${f.count}件)\n`;
+                        }
+                        return { content: [{ type: "text", text }] };
+                    }
+                    const folder = matched[0];
+                    const attachmentIds = await client.getFileBirdAttachmentIds(folder.id);
+                    if (!attachmentIds || attachmentIds.length === 0) {
+                        return { content: [{ type: "text", text: `📁 ${folder.name} (0件)\n\n❌ フォルダ内にメディアがありません。` }] };
+                    }
+                    folderIncludeIds = attachmentIds;
+                    const totalCount = attachmentIds.length;
+                    const limited = totalCount > 100;
+                    folderInfo = `📁 Folder: ${folder.name} (${totalCount}件${limited ? '、先頭100件から検索' : ''})\n`;
+                }
+
+                // --- keyword search (with or without folder filter) ---
+                if (args?.query) {
+                    const variants = generateSearchVariants(args.query, args?.strip, args?.prefix);
+                    const results = await Promise.allSettled(
+                        variants.map(v => client.searchMedia(v, perPage, folderIncludeIds))
+                    );
+
+                    const seenIds = new Set();
+                    const hits = [];
+                    for (let i = 0; i < results.length; i++) {
+                        if (results[i].status !== 'fulfilled') continue;
+                        for (const item of results[i].value) {
+                            if (seenIds.has(item.id)) continue;
+                            seenIds.add(item.id);
+                            hits.push({
+                                id: item.id,
+                                title: item.title?.rendered || '',
+                                alt: item.alt_text || '',
+                                url: item.source_url || '',
+                                width: item.media_details?.width || null,
+                                height: item.media_details?.height || null,
+                                matched: variants[i],
+                            });
+                        }
+                    }
+
+                    let text = folderInfo;
+                    text += `🔍 Search: "${args.query}"\n`;
+                    text += `🔄 Variants (${variants.length}): ${variants.join(', ')}\n\n`;
+
+                    if (hits.length === 0) {
+                        text += '❌ No results found.';
+                    } else {
+                        text += `📷 ${hits.length} result(s):\n\n`;
+                        for (const h of hits) {
+                            text += `  [ID: ${h.id}] ${h.title}\n`;
+                            text += `    Alt: ${h.alt}\n`;
+                            text += `    URL: ${h.url}\n`;
+                            if (h.width && h.height) text += `    Size: ${h.width}x${h.height}\n`;
+                            text += `    Matched: "${h.matched}"\n\n`;
+                        }
+                    }
+                    return { content: [{ type: "text", text }] };
+                }
+
+                // --- folder only (no query) ---
+                const mediaItems = await client.searchMedia(null, perPage, folderIncludeIds);
+                let text = folderInfo + '\n';
+                if (!mediaItems || mediaItems.length === 0) {
+                    text += '❌ No results found.';
+                } else {
+                    text += `📷 ${mediaItems.length} result(s):\n\n`;
+                    for (const item of mediaItems) {
+                        text += `  [ID: ${item.id}] ${item.title?.rendered || ''}\n`;
+                        text += `    Alt: ${item.alt_text || ''}\n`;
+                        text += `    URL: ${item.source_url || ''}\n`;
+                        const w = item.media_details?.width, h = item.media_details?.height;
+                        if (w && h) text += `    Size: ${w}x${h}\n`;
+                        text += '\n';
+                    }
+                }
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "list_media_folders": {
+                const siteName = args?.site || 'default';
+                let client;
+                try { client = registry.get(siteName); }
+                catch (e) { return errorResponse("list_media_folders", e.message, siteName); }
+
+                if (!client.filebirdToken) {
+                    return { content: [{ type: "text", text: "⚠️ FileBird 未導入または APIキーが未設定です。\nconnections.json に filebirdToken を追加してください。" }] };
+                }
+                const folders = await client.getFileBirdFolders();
+                if (!folders) {
+                    return errorResponse("list_media_folders", "FileBird API へのアクセスに失敗しました", siteName);
+                }
+                const flat = flattenFileBirdFolders(folders);
+                let text = `📁 FileBird フォルダ一覧 (${flat.length}件)\n\n`;
+                for (const f of flat) {
+                    text += `  [ID: ${f.id}] ${f.name} (${f.count}件)\n`;
+                }
+                return { content: [{ type: "text", text }] };
+            }
+
             case "list_connections": {
                 const conns = registry.list();
                 const text = conns.map(c => {
@@ -4375,6 +5476,103 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: "text", text: `✅ フィードバックを送信しました` }] };
             }
 
+            case "search_asp_link": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                const slug = args?.slug?.trim() || undefined;
+                const search = args?.search?.trim() || undefined;
+
+                if (slug && search) {
+                    return { content: [{ type: "text", text: "❌ slug と search は同時に指定できません。どちらか一方を使用してください。" }], isError: true };
+                }
+
+                let result;
+                try {
+                    result = await client.searchAspLinks({
+                        search,
+                        slug,
+                        per_page: args?.per_page,
+                        page: args?.page,
+                    });
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ASPリンク検索エラー: ${e.message}` }], isError: true };
+                }
+
+                const items = result.items || [];
+                if (items.length === 0) {
+                    return { content: [{ type: "text", text: "🔗 該当するASPリンクはありません。" }] };
+                }
+
+                const list = items.map(item => {
+                    const lines = [
+                        `  [${item.id}] ${item.title}`,
+                        `    案件ID: ${item.data_id} | slug: ${item.slug} | permalink: ${item.permalink}`,
+                    ];
+                    if (item.asp_url) lines.push(`    ASP URL: ${item.asp_url}`);
+                    if (item.asp_url_sp) lines.push(`    ASP URL(B): ${item.asp_url_sp}`);
+                    if (item.direct_url) lines.push(`    直リンク: ${item.direct_url}`);
+                    lines.push(`    tag: ${item.tag}`);
+                    return lines.join('\n');
+                }).join('\n\n');
+
+                let text = `🔗 ASPリンク検索結果 (${items.length}件 / 全${result.total}件)\n\n${list}`;
+                if (result.total_pages > 1) {
+                    text += `\n\n📄 ページ: ${result.page} / ${result.total_pages}`;
+                }
+
+                return { content: [{ type: "text", text }] };
+            }
+
+            case "register_asp_link": {
+                let client;
+                try {
+                    client = registry.get(args?.site);
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ${e.message}` }], isError: true };
+                }
+
+                if (!args?.title || !args?.slug || !args?.asp_url) {
+                    return { content: [{ type: "text", text: "❌ title, slug, asp_url は必須です。" }], isError: true };
+                }
+
+                let result;
+                try {
+                    result = await client.createAspLink({
+                        title: args.title,
+                        slug: args.slug,
+                        asp_id: args?.asp_id,
+                        asp_name: args?.asp_name,
+                        asp_url: args.asp_url,
+                        asp_url_sp: args?.asp_url_sp,
+                        direct_url: args?.direct_url,
+                        permalink: args?.permalink,
+                    });
+                } catch (e) {
+                    return { content: [{ type: "text", text: `❌ ASPリンク登録エラー: ${e.message}` }], isError: true };
+                }
+
+                const lines = [
+                    `✅ ASPリンク登録完了`,
+                    ``,
+                    `  ID: ${result.id}`,
+                    `  タイトル: ${result.title}`,
+                    `  slug: ${result.slug}`,
+                    `  permalink: ${result.permalink}`,
+                    `  案件ID: ${result.data_id}`,
+                ];
+                if (result.asp_url) lines.push(`  ASP URL: ${result.asp_url}`);
+                if (result.asp_url_sp) lines.push(`  ASP URL(B): ${result.asp_url_sp}`);
+                if (result.direct_url) lines.push(`  直リンク: ${result.direct_url}`);
+                lines.push(`  tag: ${result.tag}`);
+
+                return { content: [{ type: "text", text: lines.join('\n') }] };
+            }
+
             default:
                 throw new Error(`Unknown tool: ${name}`);
         } })();