@webmcp-bridge/adapter-x 0.5.1 → 0.5.3

package/dist/adapter.js

@@ -480,6 +480,43 @@ const TOOL_DEFINITIONS = [
             readOnlyHint: true,
         },
     },
+    {
+        name: "article.listDrafts",
+        description: "List existing X article drafts from the authenticated account",
+        inputSchema: {
+            type: "object",
+            description: "List article drafts owned by the authenticated X account.",
+            properties: {},
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
+    {
+        name: "article.getDraft",
+        description: "Read one X article draft by id, preview url, or edit url",
+        inputSchema: {
+            type: "object",
+            description: "Fetch one draft from the X article editor using article id, preview URL, or edit URL.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Draft preview URL or edit URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Draft article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+            },
+            additionalProperties: false,
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    },
     {
         name: "article.draftMarkdown",
         description: "Create one X article draft from a local markdown file",
@@ -509,6 +546,45 @@ const TOOL_DEFINITIONS = [
             additionalProperties: false,
         },
     },
+    {
+        name: "article.upsertDraftMarkdown",
+        description: "Create or update one X article draft from a local markdown file",
+        inputSchema: {
+            type: "object",
+            description: "Create a new draft when id/url is omitted, or update the existing draft identified by id, preview URL, or edit URL.",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Draft preview URL or edit URL.",
+                    minLength: 1,
+                },
+                id: {
+                    type: "string",
+                    description: "Draft article id. Used when url is not provided.",
+                    minLength: 1,
+                },
+                markdownPath: {
+                    type: "string",
+                    description: "Absolute local file path to the markdown file to apply.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+                title: {
+                    type: "string",
+                    description: "Optional title override. When omitted, the first markdown heading becomes the article title.",
+                    minLength: 1,
+                },
+                coverImagePath: {
+                    type: "string",
+                    description: "Optional absolute local image path for the article cover image when creating a new draft.",
+                    minLength: 1,
+                    "x-uxc-kind": "file-path",
+                },
+            },
+            required: ["markdownPath"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "article.publishMarkdown",
         description: "Publish one X article from a local markdown file",
@@ -1001,6 +1077,215 @@ function extractArticleTitle(markdown, markdownPath, explicitTitle) {
     }
     return basename(markdownPath, extname(markdownPath)).trim() || "Untitled";
 }
+function normalizeArticleTitleForComparison(value) {
+    return value
+        .normalize("NFKC")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .trim();
+}
+function normalizeArticleMarkdown(markdown, markdownPath, explicitTitle) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    const explicit = typeof explicitTitle === "string" ? explicitTitle.trim() : "";
+    const derivedTitle = extractArticleTitle(normalized, markdownPath, explicitTitle);
+    const comparisonTitle = normalizeArticleTitleForComparison(derivedTitle);
+    const output = [];
+    let insideFence = false;
+    let firstH1Handled = false;
+    for (const line of lines) {
+        if (/^\s*```/.test(line)) {
+            insideFence = !insideFence;
+            output.push(line);
+            continue;
+        }
+        if (insideFence) {
+            output.push(line);
+            continue;
+        }
+        const match = line.match(/^(\s*)#\s+(.+?)\s*$/);
+        if (!match) {
+            output.push(line);
+            continue;
+        }
+        const headingText = (match[2] ?? "").trim();
+        if (!firstH1Handled) {
+            firstH1Handled = true;
+            if (!explicit || normalizeArticleTitleForComparison(headingText) === comparisonTitle) {
+                continue;
+            }
+        }
+        output.push(`${match[1]}## ${headingText}`);
+    }
+    const bodyMarkdown = output.join("\n").replace(/^\s*\n/, "").trim();
+    return {
+        title: derivedTitle,
+        bodyMarkdown,
+    };
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function convertMarkdownInlineToHtml(value) {
+    const placeholders = [];
+    const reserve = (html) => {
+        const token = `__WEBMCP_HTML_${placeholders.length}__`;
+        placeholders.push(html);
+        return token;
+    };
+    let rendered = value
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, altRaw, destinationRaw) => {
+        const alt = escapeHtml(altRaw.trim());
+        const destination = escapeHtml(stripMarkdownImageDestination(destinationRaw));
+        return reserve(`<img src="${destination}" alt="${alt}">`);
+    })
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, textRaw, hrefRaw) => {
+        const text = escapeHtml(textRaw.trim() || hrefRaw.trim());
+        const href = escapeHtml(hrefRaw.trim());
+        return reserve(`<a href="${href}">${text}</a>`);
+    })
+        .replace(/`([^`]+)`/g, (_match, codeRaw) => reserve(`<code>${escapeHtml(codeRaw)}</code>`))
+        .replace(/\*\*([^*]+)\*\*/g, (_match, textRaw) => reserve(`<strong>${escapeHtml(textRaw)}</strong>`))
+        .replace(/\*([^*]+)\*/g, (_match, textRaw) => reserve(`<em>${escapeHtml(textRaw)}</em>`));
+    rendered = escapeHtml(rendered);
+    return rendered.replace(/__WEBMCP_HTML_(\d+)__/g, (_match, indexRaw) => {
+        const index = Number.parseInt(indexRaw, 10);
+        return placeholders[index] ?? "";
+    });
+}
+function convertMarkdownToHtml(markdown) {
+    const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+    const blocks = [];
+    let index = 0;
+    const flushParagraph = (paragraphLines) => {
+        if (paragraphLines.length === 0) {
+            return;
+        }
+        const text = paragraphLines.join(" ").trim();
+        if (!text) {
+            return;
+        }
+        blocks.push(`<p>${convertMarkdownInlineToHtml(text)}</p>`);
+    };
+    while (index < lines.length) {
+        const line = lines[index] ?? "";
+        const trimmed = line.trim();
+        if (!trimmed) {
+            index += 1;
+            continue;
+        }
+        const fenceMatch = trimmed.match(/^```([^`]*)$/);
+        if (fenceMatch) {
+            const language = escapeHtml(fenceMatch[1]?.trim() ?? "");
+            const codeLines = [];
+            index += 1;
+            while (index < lines.length && !lines[index].trim().startsWith("```")) {
+                codeLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length) {
+                index += 1;
+            }
+            const code = escapeHtml(codeLines.join("\n"));
+            blocks.push(language ? `<pre><code class="language-${language}">${code}</code></pre>` : `<pre><code>${code}</code></pre>`);
+            continue;
+        }
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = Math.min(6, headingMatch[1].length);
+            const content = convertMarkdownInlineToHtml(headingMatch[2].trim());
+            blocks.push(`<h${level}>${content}</h${level}>`);
+            index += 1;
+            continue;
+        }
+        const bulletMatch = trimmed.match(/^[-*+]\s+(.+)$/);
+        if (bulletMatch) {
+            const items = [];
+            while (index < lines.length) {
+                const itemLine = lines[index].trim();
+                const match = itemLine.match(/^[-*+]\s+(.+)$/);
+                if (!match) {
+                    break;
+                }
+                items.push(`<li>${convertMarkdownInlineToHtml(match[1].trim())}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ul>${items.join("")}</ul>`);
+            continue;
+        }
+        const orderedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+        if (orderedMatch) {
+            const items = [];
+            while (index < lines.length) {
+                const itemLine = lines[index].trim();
+                const match = itemLine.match(/^\d+\.\s+(.+)$/);
+                if (!match) {
+                    break;
+                }
+                items.push(`<li>${convertMarkdownInlineToHtml(match[1].trim())}</li>`);
+                index += 1;
+            }
+            blocks.push(`<ol>${items.join("")}</ol>`);
+            continue;
+        }
+        const paragraphLines = [];
+        while (index < lines.length) {
+            const paragraphLine = lines[index] ?? "";
+            const paragraphTrimmed = paragraphLine.trim();
+            if (!paragraphTrimmed) {
+                break;
+            }
+            if (/^```/.test(paragraphTrimmed) || /^(#{1,6})\s+/.test(paragraphTrimmed) || /^[-*+]\s+/.test(paragraphTrimmed) || /^\d+\.\s+/.test(paragraphTrimmed)) {
+                break;
+            }
+            paragraphLines.push(paragraphLine.trim());
+            index += 1;
+        }
+        flushParagraph(paragraphLines);
+    }
+    return blocks.join("\n");
+}
+function convertMarkdownLineToPlainText(line) {
+    return line
+        .replace(/^#{1,6}\s+/, "")
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .replace(/^>\s+/, "")
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, "$1")
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function extractArticleConfirmationSnippets(markdown) {
+    const snippets = [];
+    let insideFence = false;
+    for (const rawLine of markdown.replace(/\r\n/g, "\n").split("\n")) {
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (/^```/.test(trimmed)) {
+            insideFence = !insideFence;
+            continue;
+        }
+        const normalized = insideFence ? trimmed : convertMarkdownLineToPlainText(trimmed);
+        if (normalized) {
+            snippets.push(normalized);
+        }
+        if (snippets.length >= 3) {
+            break;
+        }
+    }
+    return snippets;
+}
 function prepareArticleMarkdown(markdown, markdownPath) {
     const inlineImages = [];
     let nextIndex = 1;
@@ -1026,6 +1311,7 @@ function prepareArticleMarkdown(markdown, markdownPath) {
     });
     return {
         markdown: prepared,
+        html: convertMarkdownToHtml(prepared),
         inlineImages,
     };
 }
@@ -3255,37 +3541,53 @@ async function setArticleTitle(page, title) {
         .then(() => true)
         .catch(() => false);
 }
-async function pasteArticleMarkdown(page, markdown) {
-    let success = false;
+async function pasteArticleMarkdown(page, markdown, html) {
+    let pasted = false;
     if (typeof page.locator === "function") {
         const composerLocator = page.locator("[data-testid='composer'][role='textbox']").first();
-        success = await composerLocator.click().then(() => true).catch(() => false);
-        if (success) {
-            const wroteClipboard = await page.evaluate(async ({ value }) => {
+        const clicked = await composerLocator.click().then(() => true).catch(() => false);
+        if (clicked) {
+            const wroteClipboard = await page.evaluate(async ({ plainText, htmlText }) => {
                 try {
-                    await navigator.clipboard.writeText(value);
+                    const ClipboardItemCtor = window.ClipboardItem;
+                    if (typeof navigator.clipboard?.write === "function" && ClipboardItemCtor) {
+                        const items = {
+                            "text/plain": new Blob([plainText], { type: "text/plain" }),
+                        };
+                        if (typeof htmlText === "string" && htmlText.trim().length > 0) {
+                            items["text/html"] = new Blob([htmlText], { type: "text/html" });
+                        }
+                        await navigator.clipboard.write([new ClipboardItemCtor(items)]);
+                    }
+                    else if (typeof navigator.clipboard?.writeText === "function") {
+                        await navigator.clipboard.writeText(plainText);
+                    }
+                    else {
+                        return false;
+                    }
                     return true;
                 }
                 catch {
                     return false;
                 }
-            }, { value: markdown }).catch(() => false);
+            }, { plainText: markdown, htmlText: html }).catch(() => false);
             if (wroteClipboard) {
-                success = await page.keyboard.press("Meta+V").then(() => true).catch(() => false);
+                const pasteShortcut = process.platform === "darwin" ? "Meta+V" : "Control+V";
+                pasted = await page.keyboard.press(pasteShortcut).then(() => true).catch(() => false);
             }
-            if (!success) {
+            if (!pasted) {
                 const keyboard = page.keyboard;
                 if (typeof keyboard.insertText === "function") {
-                    success = await keyboard.insertText(markdown).then(() => true).catch(() => false);
+                    pasted = await keyboard.insertText(markdown).then(() => true).catch(() => false);
                 }
                 else if (typeof keyboard.type === "function") {
-                    success = await keyboard.type(markdown).then(() => true).catch(() => false);
+                    pasted = await keyboard.type(markdown).then(() => true).catch(() => false);
                 }
             }
         }
     }
-    if (!success) {
-        success = await page.evaluate(({ op, markdownText }) => {
+    if (!pasted) {
+        pasted = await page.evaluate(({ op, markdownText, htmlText }) => {
             if (op !== "article_paste_markdown") {
                 return false;
             }
@@ -3297,6 +3599,9 @@ async function pasteArticleMarkdown(page, markdown) {
             const data = new DataTransfer();
             data.setData("text/plain", markdownText);
             data.setData("text/markdown", markdownText);
+            if (typeof htmlText === "string" && htmlText.trim().length > 0) {
+                data.setData("text/html", htmlText);
+            }
             const event = new ClipboardEvent("paste", {
                 bubbles: true,
                 cancelable: true,
@@ -3304,16 +3609,12 @@ async function pasteArticleMarkdown(page, markdown) {
             });
             composer.dispatchEvent(event);
             return true;
-        }, { op: "article_paste_markdown", markdownText: markdown }).catch(() => false);
+        }, { op: "article_paste_markdown", markdownText: markdown, htmlText: html }).catch(() => false);
     }
-    if (!success) {
+    if (!pasted) {
         return false;
     }
-    const requiredSnippets = markdown
-        .split(/\n+/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .slice(0, 3);
+    const requiredSnippets = extractArticleConfirmationSnippets(markdown);
     if (requiredSnippets.length === 0) {
         return true;
     }
@@ -3422,6 +3723,29 @@ async function uploadArticleFile(page, filePath) {
         return false;
     }
 }
+async function waitForArticleCoverApplied(page) {
+    return await page
+        .waitForFunction(() => {
+        const hasRemoveControl = Array.from(document.querySelectorAll("button, div[role='button']")).some((element) => {
+            const aria = (element.getAttribute("aria-label") || "").toLowerCase();
+            const text = (element.textContent || "").replace(/\s+/g, " ").trim().toLowerCase();
+            return aria.includes("remove photo") || text === "remove photo";
+        });
+        const coverImages = Array.from((document.querySelector("main") ?? document.body).querySelectorAll("img[src]"))
+            .filter((img) => !img.closest("nav, header, aside"))
+            .map((img) => ({
+            url: img.currentSrc || img.src,
+            width: img.naturalWidth || 0,
+            height: img.naturalHeight || 0,
+        }))
+            .filter((item) => /^https?:\/\//.test(item.url))
+            .filter((item) => !/\/profile_images\/|\/emoji\/|\/hashflags\//.test(item.url))
+            .filter((item) => item.width >= 200 || item.height >= 120);
+        return hasRemoveControl && coverImages.length > 0;
+    }, undefined, { timeout: 15_000 })
+        .then(() => true)
+        .catch(() => false);
+}
 async function placeArticleCursorAtMarker(page, marker) {
     return ((await page.evaluate(({ op, markerText }) => {
         if (op !== "article_place_marker") {
@@ -3519,9 +3843,24 @@ function parseArticleIdFromUrl(url) {
     if (!ALLOWED_X_HOSTS.has(parsed.hostname.toLowerCase())) {
         return undefined;
     }
-    const match = parsed.pathname.match(/^\/(?:compose\/articles\/edit|i\/article|i\/articles|[^/]+\/article|articles)\/(\d+)(?:\/|$)/);
+    const match = parsed.pathname.match(/^\/(?:compose\/articles\/edit|i\/article|i\/articles|[^/]+\/article|articles)\/(\d+)(?:\/preview)?(?:\/|$)/);
     return match?.[1];
 }
+function buildArticleEditUrl(articleId) {
+    return `https://x.com/compose/articles/edit/${encodeURIComponent(articleId)}`;
+}
+function buildArticlePreviewUrl(articleId) {
+    return `https://x.com/i/articles/${encodeURIComponent(articleId)}/preview`;
+}
+function isArticlePreviewUrl(url) {
+    try {
+        const parsed = new URL(url, "https://x.com");
+        return /\/preview(?:\/|$)/.test(parsed.pathname) && parseArticleIdFromUrl(parsed.toString()) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
 async function waitForCapturedOperation(page, op, timeoutMs = 10_000) {
     await page.waitForFunction(({ targetOp }) => {
         const globalAny = window;
@@ -3566,7 +3905,9 @@ async function readArticleFromEditorPage(page, articleId, sessionScoped) {
             normalize(document.querySelector("h1")?.innerText || "");
         const composer = document.querySelector("[data-testid='composer'][role='textbox']");
         const rawText = (composer?.innerText || composer?.textContent || "").trim();
-        const images = Array.from(document.querySelectorAll("img[src]"))
+        const editorRoot = document.querySelector("main") ?? document.body;
+        const images = Array.from(editorRoot.querySelectorAll("img[src]"))
+            .filter((img) => !img.closest("nav, header, aside, [data-testid='SideNav_AccountSwitcher_Button']"))
             .map((img) => ({
             url: img.currentSrc || img.src,
             alt: normalize(img.alt || ""),
@@ -3574,7 +3915,8 @@ async function readArticleFromEditorPage(page, articleId, sessionScoped) {
             height: img.naturalHeight || 0,
         }))
             .filter((item) => /^https?:\/\//.test(item.url))
-            .filter((item) => item.width > 64 || item.height > 64);
+            .filter((item) => item.width > 64 || item.height > 64)
+            .filter((item) => !/\/profile_images\/|\/emoji\/|\/hashflags\//.test(item.url));
         const deduped = new Map();
         for (const image of images) {
             if (!deduped.has(image.url)) {
@@ -3609,19 +3951,270 @@ async function readArticleFromEditorPage(page, articleId, sessionScoped) {
             editUrl: typeof article.editUrl === "string" ? article.editUrl : page.url(),
             images: inlineImages,
             source: "editor",
+            published: false,
         },
     };
+    if (articleId) {
+        output.article.previewUrl = buildArticlePreviewUrl(articleId);
+    }
     if (coverImage && typeof coverImage === "object" && coverImage !== null && "url" in coverImage) {
         output.article.coverImageUrl = coverImage.url;
+        output.article.hasCoverImage = true;
+    }
+    else {
+        output.article.hasCoverImage = false;
     }
     if (articleId) {
         output.article.sessionScoped = sessionScoped === true;
     }
-    if (sessionScoped === true) {
-        output.article.published = false;
-    }
     return output;
 }
+async function listArticleDrafts(page) {
+    return await withEphemeralPage(page, "https://x.com/compose/articles", async (articlePage) => {
+        await articlePage.waitForTimeout(1_000);
+        await waitForCapturedOperation(articlePage, "ArticleEntitiesSlice", 12_000);
+        const result = await articlePage.evaluate(async ({ op }) => {
+            if (op !== "article_list_drafts") {
+                return undefined;
+            }
+            const normalizeInline = (value) => value.replace(/\s+/g, " ").trim();
+            const parseJsonSafely = (value) => {
+                if (!value) {
+                    return {};
+                }
+                try {
+                    const parsed = JSON.parse(value);
+                    return typeof parsed === "object" && parsed !== null ? parsed : {};
+                }
+                catch {
+                    return {};
+                }
+            };
+            const toHttpsImage = (value) => typeof value === "string" && /^https?:\/\//.test(value) ? value : undefined;
+            const sanitizeHeaders = (headers) => {
+                const blockedPrefixes = ["sec-", ":"];
+                const blockedExact = new Set(["host", "content-length", "cookie", "origin", "referer", "connection"]);
+                const output = {};
+                if (!headers) {
+                    return output;
+                }
+                for (const [key, value] of Object.entries(headers)) {
+                    const normalized = key.toLowerCase();
+                    if (blockedExact.has(normalized) || blockedPrefixes.some((prefix) => normalized.startsWith(prefix))) {
+                        continue;
+                    }
+                    output[normalized] = value;
+                }
+                return output;
+            };
+            const extractUpdatedAt = (record) => {
+                const metadata = record.metadata ?? {};
+                const candidates = [
+                    metadata.updated_at_secs,
+                    metadata.last_edited_at_secs,
+                    metadata.last_updated_at_secs,
+                    metadata.created_at_secs,
+                    metadata.first_published_at_secs,
+                ];
+                for (const candidate of candidates) {
+                    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+                        return new Date(candidate * 1000).toISOString();
+                    }
+                }
+                return undefined;
+            };
+            const extractNextCursor = (sliceInfo) => {
+                if (!sliceInfo || typeof sliceInfo !== "object" || Array.isArray(sliceInfo)) {
+                    return undefined;
+                }
+                const record = sliceInfo;
+                const keys = ["next_cursor", "nextCursor", "cursor", "bottom_cursor"];
+                for (const key of keys) {
+                    if (typeof record[key] === "string" && record[key]) {
+                        return record[key];
+                    }
+                }
+                return undefined;
+            };
+            const globalAny = window;
+            const entries = Array.isArray(globalAny.__WEBMCP_X_CAPTURE__?.entries)
+                ? globalAny.__WEBMCP_X_CAPTURE__?.entries ?? []
+                : [];
+            const template = (() => {
+                for (let i = entries.length - 1; i >= 0; i -= 1) {
+                    const entry = entries[i];
+                    if (!entry || entry.op !== "ArticleEntitiesSlice" || !entry.url || !entry.method) {
+                        continue;
+                    }
+                    return {
+                        url: entry.url,
+                        method: entry.method,
+                        headers: entry.headers ?? {},
+                    };
+                }
+                return null;
+            })();
+            if (!template) {
+                return { drafts: [] };
+            }
+            const templateUrl = new URL(template.url, location.origin);
+            const templateVariables = parseJsonSafely(templateUrl.searchParams.get("variables"));
+            const templateFeatures = parseJsonSafely(templateUrl.searchParams.get("features"));
+            const headers = sanitizeHeaders(template.headers);
+            const userId = typeof templateVariables.userId === "string" ? templateVariables.userId : "";
+            if (!userId) {
+                return { drafts: [] };
+            }
+            const fetchSlice = async (cursor) => {
+                const vars = {
+                    ...templateVariables,
+                    userId,
+                    lifecycle: "Draft",
+                    count: 20,
+                };
+                if (cursor) {
+                    vars.cursor = cursor;
+                }
+                else {
+                    delete vars.cursor;
+                }
+                const requestUrl = new URL(template.url, location.origin);
+                requestUrl.searchParams.set("variables", JSON.stringify(vars));
+                if (Object.keys(templateFeatures).length > 0) {
+                    requestUrl.searchParams.set("features", JSON.stringify(templateFeatures));
+                }
+                const response = await fetch(requestUrl.toString(), {
+                    method: template.method,
+                    headers,
+                    credentials: "include",
+                });
+                if (!response.ok) {
+                    throw new Error(`http_${response.status}`);
+                }
+                return await response.json();
+            };
+            const drafts = [];
+            let cursor;
+            for (let pageIndex = 0; pageIndex < 8; pageIndex += 1) {
+                let responseJson;
+                try {
+                    responseJson = await fetchSlice(cursor);
+                }
+                catch {
+                    break;
+                }
+                const slice = responseJson?.data?.user;
+                const result = slice?.result?.articles_article_mixer_slice;
+                const items = Array.isArray(result?.items) ? result.items : [];
+                for (const rawItem of items) {
+                    if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+                        continue;
+                    }
+                    const item = rawItem;
+                    const articleResult = item.article_entity_results?.result;
+                    if (!articleResult) {
+                        continue;
+                    }
+                    const restId = typeof articleResult.rest_id === "string" ? articleResult.rest_id : "";
+                    if (!restId) {
+                        continue;
+                    }
+                    const coverMedia = articleResult.cover_media;
+                    const hasCoverImage = toHttpsImage(coverMedia?.original_img_url) ??
+                        toHttpsImage(coverMedia?.media_url_https) ??
+                        toHttpsImage(coverMedia?.media_url);
+                    drafts.push({
+                        id: restId,
+                        title: typeof articleResult.title === "string" ? normalizeInline(articleResult.title) : "",
+                        updatedAt: extractUpdatedAt(articleResult),
+                        hasCoverImage: Boolean(hasCoverImage),
+                        editUrl: buildArticleEditUrl(restId),
+                        previewUrl: buildArticlePreviewUrl(restId),
+                    });
+                }
+                cursor = extractNextCursor(result?.slice_info);
+                if (!cursor) {
+                    break;
+                }
+            }
+            return { drafts };
+        }, { op: "article_list_drafts" }).catch(() => undefined);
+        if (!result || typeof result !== "object" || Array.isArray(result)) {
+            return errorResult("UPSTREAM_CHANGED", "article drafts could not be listed");
+        }
+        const drafts = Array.isArray(result.drafts)
+            ? result.drafts
+            : [];
+        const normalizedDrafts = drafts
+            .map((draft) => {
+            if (!draft || typeof draft !== "object" || Array.isArray(draft)) {
+                return undefined;
+            }
+            const entry = draft;
+            if (typeof entry.id !== "string" ||
+                typeof entry.editUrl !== "string" ||
+                typeof entry.previewUrl !== "string") {
+                return undefined;
+            }
+            return {
+                id: entry.id,
+                editUrl: entry.editUrl,
+                previewUrl: entry.previewUrl,
+                title: typeof entry.title === "string" ? entry.title : "",
+                hasCoverImage: entry.hasCoverImage === true,
+                ...(typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {}),
+            };
+        })
+            .filter((draft) => draft !== undefined);
+        for (const draft of normalizedDrafts) {
+            if (draft.hasCoverImage) {
+                continue;
+            }
+            const cachedPage = getCachedArticleDraftPage(page, draft.id);
+            if (cachedPage) {
+                const cachedRead = await readArticleFromEditorPage(cachedPage, draft.id, true);
+                if (cachedRead &&
+                    typeof cachedRead === "object" &&
+                    !Array.isArray(cachedRead) &&
+                    "article" in cachedRead &&
+                    cachedRead.article &&
+                    typeof cachedRead.article === "object" &&
+                    !Array.isArray(cachedRead.article) &&
+                    cachedRead.article.hasCoverImage === true) {
+                    draft.hasCoverImage = true;
+                    continue;
+                }
+            }
+            const liveRead = await withEphemeralPage(page, buildArticleEditUrl(draft.id), async (draftPage) => {
+                await waitForArticleEditorSurface(draftPage);
+                await ensureArticleDraftLoaded(draftPage, draft.id);
+                return await readArticleFromEditorPage(draftPage, draft.id, false);
+            }).catch(() => undefined);
+            if (liveRead &&
+                typeof liveRead === "object" &&
+                !Array.isArray(liveRead) &&
+                "article" in liveRead &&
+                liveRead.article &&
+                typeof liveRead.article === "object" &&
+                !Array.isArray(liveRead.article) &&
+                liveRead.article.hasCoverImage === true) {
+                draft.hasCoverImage = true;
+            }
+        }
+        return {
+            drafts: normalizedDrafts,
+        };
+    });
+}
+async function getArticleDraft(page, targetUrl) {
+    const articleId = parseArticleIdFromUrl(targetUrl);
+    if (!articleId) {
+        return errorResult("VALIDATION_ERROR", "url or id is required");
+    }
+    return await withArticleDraftPage(page, buildArticleEditUrl(articleId), async (articlePage, resolvedId, sessionScoped) => {
+        return await readArticleFromEditorPage(articlePage, resolvedId ?? articleId, sessionScoped);
+    });
+}
 function parseArticleReadErrorCode(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return undefined;
@@ -4327,7 +4920,7 @@ async function readArticleByUrl(page, targetUrl, authorHandle) {
             }
         }
     }
-    const useEditor = targetUrl.includes("/compose/articles/edit/");
+    const useEditor = targetUrl.includes("/compose/articles/edit/") || isArticlePreviewUrl(targetUrl);
     if (articleId) {
         const cachedPage = getCachedArticleDraftPage(page, articleId);
         if (cachedPage) {
@@ -4337,7 +4930,7 @@ async function readArticleByUrl(page, targetUrl, authorHandle) {
         }
     }
     if (useEditor) {
-        return await withEphemeralPage(page, targetUrl, async (articlePage) => {
+        return await withEphemeralPage(page, articleId ? buildArticleEditUrl(articleId) : targetUrl, async (articlePage) => {
             await waitForArticleEditorSurface(articlePage);
             await ensureArticleDraftLoaded(articlePage, articleId);
             return await readArticleFromEditorPage(articlePage, articleId, false);
@@ -4614,8 +5207,9 @@ async function draftArticleMarkdown(page, markdownPath, explicitTitle, coverImag
     if (markdown === undefined) {
         return errorResult("VALIDATION_ERROR", `markdownPath was not found: ${markdownPath}`);
     }
-    const title = extractArticleTitle(markdown, resolvedMarkdown.attachment.path, explicitTitle);
-    const draftAssets = prepareArticleMarkdown(markdown, resolvedMarkdown.attachment.path);
+    const normalized = normalizeArticleMarkdown(markdown, resolvedMarkdown.attachment.path, explicitTitle);
+    const title = normalized.title;
+    const draftAssets = prepareArticleMarkdown(normalized.bodyMarkdown, resolvedMarkdown.attachment.path);
     const resolvedInlineImages = [];
     for (const image of draftAssets.inlineImages) {
         const resolved = await resolveArticleAttachment(image.path, image.marker);
@@ -4658,8 +5252,12 @@ async function draftArticleMarkdown(page, markdownPath, explicitTitle, coverImag
             if (!coverUploaded) {
                 return errorResult("UPSTREAM_CHANGED", "article cover upload failed");
             }
+            const coverApplied = await waitForArticleCoverApplied(articlePage);
+            if (!coverApplied) {
+                return errorResult("ACTION_UNCONFIRMED", "article cover upload was not confirmed");
+            }
         }
-        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown);
+        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown, draftAssets.html);
         if (!pasted) {
             return errorResult("UPSTREAM_CHANGED", "article markdown paste failed");
         }
@@ -4680,6 +5278,8 @@ async function draftArticleMarkdown(page, markdownPath, explicitTitle, coverImag
         };
         if (articleId) {
             output.articleId = articleId;
+            output.draftId = articleId;
+            output.previewUrl = buildArticlePreviewUrl(articleId);
             const persisted = await waitForArticleDraftPersisted(articlePage, articleId, title);
             output.persisted = persisted;
             output.sessionScoped = !persisted;
@@ -4808,6 +5408,10 @@ async function setArticleCoverImage(page, targetUrl, coverImagePath) {
         if (!coverUploaded) {
             return errorResult("UPSTREAM_CHANGED", "article cover upload failed");
         }
+        const coverApplied = await waitForArticleCoverApplied(articlePage);
+        if (!coverApplied) {
+            return errorResult("ACTION_UNCONFIRMED", "article cover upload was not confirmed");
+        }
         const output = {
             ok: true,
             editUrl: articlePage.url(),
@@ -4829,8 +5433,9 @@ async function updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitl
     if (markdown === undefined) {
         return errorResult("VALIDATION_ERROR", `markdownPath was not found: ${markdownPath}`);
     }
-    const title = extractArticleTitle(markdown, resolvedMarkdown.attachment.path, explicitTitle);
-    const draftAssets = prepareArticleMarkdown(markdown, resolvedMarkdown.attachment.path);
+    const normalized = normalizeArticleMarkdown(markdown, resolvedMarkdown.attachment.path, explicitTitle);
+    const title = normalized.title;
+    const draftAssets = prepareArticleMarkdown(normalized.bodyMarkdown, resolvedMarkdown.attachment.path);
     const resolvedInlineImages = [];
     for (const image of draftAssets.inlineImages) {
         const resolved = await resolveArticleAttachment(image.path, image.marker);
@@ -4854,7 +5459,7 @@ async function updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitl
         if (!cleared) {
             return errorResult("UPSTREAM_CHANGED", "article body controls not found");
         }
-        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown);
+        const pasted = await pasteArticleMarkdown(articlePage, draftAssets.markdown, draftAssets.html);
         if (!pasted) {
             return errorResult("UPSTREAM_CHANGED", "article markdown paste failed");
         }
@@ -4872,6 +5477,8 @@ async function updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitl
         };
         if (articleId) {
             output.articleId = articleId;
+            output.draftId = articleId;
+            output.previewUrl = buildArticlePreviewUrl(articleId);
             const persisted = await waitForArticleDraftPersisted(articlePage, articleId, title);
             output.persisted = persisted;
             output.sessionScoped = sessionScoped === true || !persisted;
@@ -4879,6 +5486,12 @@ async function updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitl
         return output;
     });
 }
+async function upsertArticleDraftMarkdown(page, targetUrl, markdownPath, explicitTitle, coverImagePath) {
+    if (targetUrl) {
+        return await updateArticleMarkdown(page, targetUrl, markdownPath, explicitTitle);
+    }
+    return await draftArticleMarkdown(page, markdownPath, explicitTitle, coverImagePath);
+}
 async function waitForGrokSurface(page) {
     await page
         .waitForFunction(() => {
@@ -5837,6 +6450,35 @@ export function createXAdapter(options) {
                 }
                 return await readArticleByUrl(page, targetUrl, authorHandle || undefined);
             }
+            if (name === "article.listDrafts") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                return await listArticleDrafts(page);
+            }
+            if (name === "article.getDraft") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                if (!id && !url) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                let articleId = id || undefined;
+                if (!articleId && url) {
+                    articleId = parseArticleIdFromUrl(url);
+                    if (!articleId) {
+                        return errorResult("VALIDATION_ERROR", "could not parse article id from url");
+                    }
+                }
+                if (!articleId) {
+                    return errorResult("VALIDATION_ERROR", "url or id is required");
+                }
+                return await getArticleDraft(page, buildArticleEditUrl(articleId));
+            }
             if (name === "article.draftMarkdown") {
                 const authCheck = await requireAuthenticated(page);
                 if (!authCheck.ok) {
@@ -5850,6 +6492,29 @@ export function createXAdapter(options) {
                 const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
                 return await draftArticleMarkdown(page, markdownPath, explicitTitle || undefined, coverImagePath || undefined);
             }
+            if (name === "article.upsertDraftMarkdown") {
+                const authCheck = await requireAuthenticated(page);
+                if (!authCheck.ok) {
+                    return authCheck.result;
+                }
+                const url = typeof args.url === "string" ? args.url.trim() : "";
+                const id = typeof args.id === "string" ? args.id.trim() : "";
+                const markdownPath = typeof args.markdownPath === "string" ? args.markdownPath.trim() : "";
+                if (!markdownPath) {
+                    return errorResult("VALIDATION_ERROR", "markdownPath is required");
+                }
+                const explicitTitle = typeof args.title === "string" ? args.title.trim() : "";
+                const coverImagePath = typeof args.coverImagePath === "string" ? args.coverImagePath.trim() : "";
+                let articleId = id || undefined;
+                if (!articleId && url) {
+                    articleId = parseArticleIdFromUrl(url);
+                    if (!articleId) {
+                        return errorResult("VALIDATION_ERROR", "url is invalid or unsupported");
+                    }
+                }
+                const targetUrl = articleId ? buildArticleEditUrl(articleId) : undefined;
+                return await upsertArticleDraftMarkdown(page, targetUrl, markdownPath, explicitTitle || undefined, coverImagePath || undefined);
+            }
             if (name === "article.publishMarkdown") {
                 const authCheck = await requireAuthenticated(page);
                 if (!authCheck.ok) {