@qcplay/cli 1.0.18 → 1.0.19

package/lib/platform-publish.js

@@ -1,4 +1,5 @@
 import { spawn } from "child_process";
+import { createHash } from "crypto";
 import fs from "fs";
 import http from "http";
 import https from "https";
@@ -12,6 +13,8 @@ import { stripWechatGuidanceHtml } from "./wechat-article.js";
 
 const PLATFORM_CONFIG_URL = "https://t4blw8ys5w.feishu.cn/wiki/OqH7wkx9PiBaTYkKeWNc35SonGf";
 const DISCORD_MESSAGE_LIMIT = 2000;
+const BROWSER_SUBMISSION_COOLDOWN_MS = 60_000;
+const BROWSER_SUBMISSION_STATE_FILE = path.join(os.homedir(), ".qcplay", "browser-submissions.json");
 const ARES_PROJECT = "阿瑞斯病毒2";
 const ARES_BILIBILI_RECHARGE_RULE = {
   name: "阿瑞斯病毒2 B站删除官充章节",
@@ -1527,6 +1530,26 @@ export function resolveTapTapPublishingOptions(article, entry = {}) {
   };
 }
 
+export function resolveTapTapTitle(article, limit = 30) {
+  const explicitTitle = tapTapMeta(article, "taptap_title");
+  const sourceTitle = explicitTitle || normalizeText(article.title || article.payload?.article_title);
+  const characters = Array.from(sourceTitle);
+  if (characters.length <= limit || explicitTitle) {
+    return sourceTitle;
+  }
+
+  const prefix = characters.slice(0, limit).join("");
+  const sentenceEnd = Math.max(...["。", "！", "？", "!", "?"].map(mark => prefix.lastIndexOf(mark)));
+  if (sentenceEnd >= 12) {
+    return prefix.slice(0, sentenceEnd + 1);
+  }
+  const phraseEnd = Math.max(...["，", ",", "、", "；", ";"].map(mark => prefix.lastIndexOf(mark)));
+  if (phraseEnd >= 12) {
+    return prefix.slice(0, phraseEnd + 1);
+  }
+  return `${characters.slice(0, Math.max(0, limit - 1)).join("")}…`;
+}
+
 export function tapTapPublishingPlan(article, entry = {}) {
   const preparedArticle = prepareTapTapArticleForProject(article, entry);
   const settings = resolveTapTapPublishingOptions(preparedArticle, entry);
@@ -1560,7 +1583,26 @@ function weiboMeta(article, ...keys) {
 }
 
 export function resolveWeiboArticleTitle(article) {
-  return weiboMeta(article, "weibo_title") || normalizeText(article.title || article.payload?.article_title);
+  const explicitTitle = weiboMeta(article, "weibo_title");
+  if (explicitTitle) {
+    return explicitTitle;
+  }
+  const sourceTitle = normalizeText(article.title || article.payload?.article_title);
+  const characters = Array.from(sourceTitle);
+  if (characters.length <= 32) {
+    return sourceTitle;
+  }
+
+  const prefix = characters.slice(0, 32).join("");
+  const sentenceEnd = Math.max(...["。", "！", "？", "!", "?"].map(mark => prefix.lastIndexOf(mark)));
+  if (sentenceEnd >= 12) {
+    return prefix.slice(0, sentenceEnd + 1);
+  }
+  const phraseEnd = Math.max(...["，", ",", "、", "；", ";"].map(mark => prefix.lastIndexOf(mark)));
+  if (phraseEnd >= 12) {
+    return prefix.slice(0, phraseEnd + 1);
+  }
+  return `${characters.slice(0, 31).join("")}…`;
 }
 
 export function resolveWeiboSuperTopic(article, entry = {}) {
@@ -1616,7 +1658,7 @@ export function buildWeiboRichContent(article) {
     structuredTables: true
   });
   const seenImages = new Set();
-  const items = content.items.filter(item => {
+  const filteredItems = content.items.filter(item => {
     if (item.type !== "image") {
       return true;
     }
@@ -1629,8 +1671,9 @@ export function buildWeiboRichContent(article) {
   });
   return {
     ...content,
-    items,
-    images: items.filter(item => item.type === "image")
+    items: filteredItems,
+    plainText: filteredItems.map(item => normalizeText(item.plain)).filter(Boolean).join("\n"),
+    images: filteredItems.filter(item => item.type === "image")
   };
 }
 
@@ -2006,6 +2049,14 @@ function safeRichCssLength(value, options = {}) {
   return pattern.test(length) ? length : "";
 }
 
+function safeRichFontFamily(value) {
+  const family = normalizeText(value).replace(/\s*!important\s*$/i, "");
+  if (!family || !/^[\w\s,'"-]+$/u.test(family)) {
+    return "";
+  }
+  return family;
+}
+
 function tapTapInlineWrappers(tag, styleValue = "", options = {}) {
   const wrappers = [];
   const add = name => {
@@ -2033,12 +2084,16 @@ function tapTapInlineWrappers(tag, styleValue = "", options = {}) {
   const letterSpacing = preserveStyles
     ? safeRichCssLength(styleValue.match(/(?:^|;)\s*letter-spacing\s*:\s*([^;]+)/i)?.[1])
     : "";
+  const fontFamily = preserveStyles
+    ? safeRichFontFamily(styleValue.match(/(?:^|;)\s*font-family\s*:\s*([^;]+)/i)?.[1])
+    : "";
   const spanStyles = [
     safeColor ? `color:${safeColor}` : "",
     safeBackground ? `background-color:${safeBackground}` : "",
     fontSize ? `font-size:${fontSize}` : "",
     lineHeight ? `line-height:${lineHeight}` : "",
-    letterSpacing ? `letter-spacing:${letterSpacing}` : ""
+    letterSpacing ? `letter-spacing:${letterSpacing}` : "",
+    fontFamily ? `font-family:${fontFamily}` : ""
   ]
     .filter(Boolean)
     .join(";");
@@ -2111,6 +2166,10 @@ function buildPlatformRichContent(article, options = {}) {
         );
         if (value) blockStyles.push(`${property}:${value}`);
       }
+      const fontFamily = safeRichFontFamily(
+        styleValue.match(/(?:^|;)\s*font-family\s*:\s*([^;]+)/i)?.[1]
+      );
+      if (fontFamily) blockStyles.push(`font-family:${fontFamily}`);
     }
     return blockStyles.length > 0 ? ` style="${blockStyles.join(";")}"` : "";
   };
@@ -2479,17 +2538,66 @@ function buildPlatformRichContent(article, options = {}) {
     const fallback = normalizeText(article.markdown);
     items.push({ type: "html", html: `<p>${escapeTapTapHtml(fallback)}</p>`, plain: fallback });
   }
+  const normalizedItems = normalizeNumberedSectionHeadings(items);
   return {
-    items,
+    items: normalizedItems,
     images,
     links,
-    plainText: items
+    plainText: normalizedItems
       .filter(item => item.type === "html")
       .map(item => item.plain)
       .join("\n")
   };
 }
 
+function isStandaloneSectionNumber(value) {
+  return /^(?:(?:第\s*)?\d{1,3}|[一二三四五六七八九十]+)(?:[、.．:：])?$/.test(normalizeText(value));
+}
+
+function mergeNumberedSectionHeading(numberItem, headingItem) {
+  const number = normalizeText(numberItem.plain);
+  const title = normalizeText(headingItem.plain);
+  const opening = String(headingItem.html || "").match(/^<(p|h[1-3])([^>]*)>/i);
+  const closing = String(headingItem.html || "").match(/<\/(p|h[1-3])>$/i);
+  if (!opening || !closing) return null;
+  const headingHtml = String(headingItem.html || "").replace(/^<(p|h[1-3])[^>]*>|<\/(p|h[1-3])>$/gi, "");
+  return {
+    ...headingItem,
+    html: `<${opening[1]}${opening[2]}>${escapeTapTapHtml(number)} ${headingHtml}</${closing[1]}>`,
+    plain: `${number} ${title}`
+  };
+}
+
+// WeChat articles sometimes split a section marker and its title into two blocks.
+// Keep the heading readable on one line while retaining the intended blank space.
+function normalizeNumberedSectionHeadings(items) {
+  const normalized = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const current = items[index];
+    const following = items[index + 1];
+    const canMerge =
+      current?.type === "html" &&
+      following?.type === "html" &&
+      current.block === "p" &&
+      isStandaloneSectionNumber(current.plain) &&
+      (/^h[1-3]$/.test(following.block || "") || /^\d{2}$/.test(normalizeText(current.plain)));
+    if (!canMerge) {
+      normalized.push(current);
+      continue;
+    }
+    const merged = mergeNumberedSectionHeading(current, following);
+    if (!merged) {
+      normalized.push(current);
+      continue;
+    }
+    normalized.push({ type: "html", html: "<p><br></p>", plain: "", block: "p", align: "" });
+    normalized.push(merged);
+    normalized.push({ type: "html", html: "<p><br></p>", plain: "", block: "p", align: "" });
+    index += 1;
+  }
+  return normalized;
+}
+
 export function buildBilibiliRichContent(article) {
   return buildPlatformRichContent(article, {
     preserveBackground: true,
@@ -2507,9 +2615,29 @@ export function buildHaoyouRichContent(article) {
     structuredTables: true
   });
   const flattenInlineSpans = isWechatImportedArticle(article);
+  // Most nested WeChat spans are flattened for the Haoyou Quill clipboard
+  // parser, but a secret code is commonly the coloured line immediately before
+  // a “red text is the code” hint. Keeping that tiny group intact preserves the
+  // source visual distinction without exposing the rest of the article to the
+  // parser issue.
+  const secretStyleItems = new Set();
+  content.items.forEach((item, index) => {
+    if (item.type !== "html") return;
+    const text = normalizeText(item.plain);
+    if (!/(?:密令|兑换码|礼包码|福利码)/.test(text)) return;
+    secretStyleItems.add(index);
+    if (/红字[^。；;\n]{0,20}(?:密令|兑换码|礼包码|福利码)/.test(text)) {
+      for (let previous = index - 1; previous >= 0; previous -= 1) {
+        if (content.items[previous].type === "html") {
+          secretStyleItems.add(previous);
+          break;
+        }
+      }
+    }
+  });
   return {
     ...content,
-    items: content.items.map(item =>
+    items: content.items.map((item, index) =>
       item.type === "html"
         ? {
             ...item,
@@ -2520,13 +2648,39 @@ export function buildHaoyouRichContent(article) {
               // WeChat's nested styled spans can also truncate their trailing
               // text in the Haoyou Quill clipboard parser. Keep their text and
               // semantic children while dropping only the wrapper.
-              .replace(flattenInlineSpans ? /<\/?span\b[^>]*>/gi : /$^/, "")
+              .replace(flattenInlineSpans && !secretStyleItems.has(index) ? /<\/?span\b[^>]*>/gi : /$^/, "")
           }
         : item
     )
   };
 }
 
+export function buildHaoyouPublishRichContent(article) {
+  const content = buildHaoyouRichContent(article);
+  return {
+    ...content,
+    items: content.items.map(item => {
+      if (item.type !== "html") return item;
+      const $ = cheerio.load(item.html, null, false);
+      $("em,i").each((_, element) => $(element).replaceWith($(element).contents()));
+      $("[style]").each((_, element) => {
+        const style = String($(element).attr("style") || "")
+          .split(";")
+          .filter(rule => !/^\s*(?:color|background(?:-color)?|font-style)\s*:/i.test(rule))
+          .map(rule => rule.trim())
+          .filter(Boolean)
+          .join(";");
+        if (style) {
+          $(element).attr("style", style);
+        } else {
+          $(element).removeAttr("style");
+        }
+      });
+      return { ...item, html: $.html() };
+    })
+  };
+}
+
 function contentTypeForFile(fileName, fallback = "application/octet-stream") {
   const extension = path.extname(fileName).toLowerCase();
   return (
@@ -2748,7 +2902,7 @@ async function waitForTapTapRichEditorState(page, bodyInput, content, options =
   throw new Error("TapTap 正文写入后未能稳定完成回读校验");
 }
 
-export async function insertTapTapRichContent(page, bodyInput, article, settings, fallbackText) {
+export async function insertTapTapRichContent(page, bodyInput, article, settings, fallbackText, options = {}) {
   if (typeof bodyInput.evaluate !== "function" || typeof bodyInput.locator !== "function") {
     await fillLocator(bodyInput, fallbackText);
     await verifyFilledValue(bodyInput, fallbackText, "正文");
@@ -2758,7 +2912,12 @@ export async function insertTapTapRichContent(page, bodyInput, article, settings
   const content = buildTapTapRichContent(article);
   const inlineImages = settings.type === "topic";
   const toolbarImageInput = inlineImages
-    ? await firstExisting(page, ['.tap-editor-toolbar input[type="file"][accept*="image"]'])
+    ? await firstExisting(page, [
+        '.tap-editor-toolbar input[type="file"][accept*="image"]',
+        '.tap-editor__toolbar input[type="file"][accept*="image"]',
+        '[class*="tap-editor"][class*="toolbar"] input[type="file"][accept*="image"]',
+        'input[type="file"][accept*="image"]:not([class*="cover"]):not([class*="post-setting"])'
+      ])
     : null;
   if (inlineImages && content.images.length > 0 && (!toolbarImageInput || typeof toolbarImageInput.setInputFiles !== "function")) {
     throw new Error("TapTap 长帖编辑器中未找到正文图片上传控件");
@@ -2777,6 +2936,9 @@ export async function insertTapTapRichContent(page, bodyInput, article, settings
       plainParts.push(item.plain);
       continue;
     }
+    if (options.skipImages) {
+      continue;
+    }
     if (inlineImages) {
       const marker = `${markerPrefix}${imageMarkers.length}`;
       htmlParts.push(`<p>${marker}</p>`);
@@ -3021,6 +3183,7 @@ export async function insertBilibiliRichContent(page, bodyInput, article, spec,
   }
 
   const content = buildBilibiliRichContent(article);
+  options.onProgress?.(`B站 正在写入文字正文（${content.plainText.length} 字）`);
   await bodyInput.fill("");
   await bodyInput.click();
   const markerPrefix = `QCPLAY_BILIBILI_IMAGE_${Date.now()}_`;
@@ -3045,11 +3208,26 @@ export async function insertBilibiliRichContent(page, bodyInput, article, spec,
       plain: plainParts.join("\n")
     });
     await page.waitForTimeout(100);
+    options.onProgress?.("B站 文字正文已写入，正在回读校验");
+    options.onProgress?.(`B站 已写入 ${content.items.length} 个正文区块，准备处理 ${imageMarkers.length} 张正文图片`);
+  }
+
+  if (options.previewOnly) {
+    options.onProgress?.("B站 文字正文已写入，等待用户在页面中核对");
+    return {
+      rich: true,
+      images: 0,
+      imagesPending: content.images.length,
+      links: content.links.length,
+      plainText: content.plainText
+    };
   }
 
   const payloadCache = new Map();
   let removedImages = 0;
-  for (const { marker, item, index } of imageMarkers) {
+  for (let markerIndex = 0; markerIndex < imageMarkers.length; markerIndex += 1) {
+    const { marker, item, index } = imageMarkers[markerIndex];
+    options.onProgress?.(`B站 正文图片 ${markerIndex + 1}/${imageMarkers.length}：正在定位插入位置`);
     const selected = await bodyInput.evaluate((element, markerValue) => {
       const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
       let textNode = walker.nextNode();
@@ -3073,6 +3251,7 @@ export async function insertBilibiliRichContent(page, bodyInput, article, spec,
       throw new Error(`B站正文图片占位位置丢失: ${item.source}`);
     }
     await page.keyboard.press("Backspace");
+    options.onProgress?.(`B站 正文图片 ${markerIndex + 1}/${imageMarkers.length}：正在上传`);
     let payload = payloadCache.get(item.source);
     if (!payload) {
       payload = await imageUploadPayload(item.source, article.articleFile, index, "B站");
@@ -3086,26 +3265,38 @@ export async function insertBilibiliRichContent(page, bodyInput, article, spec,
     });
     if (uploadResult?.removed) {
       removedImages += 1;
+      options.onProgress?.(`B站 正文图片 ${markerIndex + 1}/${imageMarkers.length}：不合规，已从正文移除`);
+    } else {
+      options.onProgress?.(`B站 正文图片 ${markerIndex + 1}/${imageMarkers.length}：上传回执已确认`);
     }
   }
 
+  options.onProgress?.("B站 正文媒体已处理，正在最终回读校验");
   let state = null;
   let previousTextLength = -1;
   let stableChecks = 0;
   for (let attempt = 0; attempt < 40; attempt += 1) {
-    state = await bodyInput.evaluate(element => ({
-      text: element.innerText,
-      images: element.querySelectorAll("img").length,
-      failedImages: element.querySelectorAll('.upload-fail, .image-upload-error, [class*="upload-error"]').length,
-      links: [...element.querySelectorAll("a[href]")].map(link => ({ href: link.href, label: link.innerText }))
-    }));
+    state = await bodyInput
+      .evaluate(
+        element => ({
+          text: element.innerText,
+          images: element.querySelectorAll("img").length,
+          failedImages: element.querySelectorAll('.upload-fail, .image-upload-error, [class*="upload-error"]').length,
+          links: [...element.querySelectorAll("a[href]")].map(link => ({ href: link.href, label: link.innerText }))
+        }),
+        undefined,
+        { timeout: 15000 }
+      )
+      .catch(error => {
+        throw new Error(`B站正文回读超时或失败：${error.message || error}`);
+      });
     const currentLength = normalizeText(state.text).length;
     stableChecks = currentLength === previousTextLength ? stableChecks + 1 : 0;
     previousTextLength = currentLength;
     if (stableChecks >= 3) break;
     await page.waitForTimeout(250);
   }
-  const expectedImages = content.images.length - removedImages;
+  const expectedImages = options.skipImages ? 0 : content.images.length - removedImages;
   if (state.failedImages > 0 || state.images < expectedImages) {
     throw new Error(`B站正文图片写入不完整，预期 ${expectedImages} 张，实际 ${state.images} 张`);
   }
@@ -3128,7 +3319,14 @@ export async function insertBilibiliRichContent(page, bodyInput, article, spec,
       throw new Error(`B站正文超链接未正确写入: ${link.href}`);
     }
   }
-  return { rich: true, images: state.images, links: content.links.length, plainText: content.plainText };
+  options.onProgress?.("B站 文字正文回读校验通过");
+  return {
+    rich: true,
+    images: state.images,
+    ...(options.skipImages ? { imagesPending: content.images.length } : {}),
+    links: content.links.length,
+    plainText: content.plainText
+  };
 }
 
 function haoyouImageUploadPayload(payload, index) {
@@ -3197,8 +3395,8 @@ async function waitForHaoyouInlineImage(page, bodyInput, imageId, source) {
   throw new Error(`好游快爆正文图片上传超时: ${source}`);
 }
 
-export async function insertHaoyouRichContent(page, bodyInput, article, fallbackText) {
-  const content = buildHaoyouRichContent(article);
+export async function insertHaoyouRichContent(page, bodyInput, article, fallbackText, options = {}) {
+  const content = buildHaoyouPublishRichContent(article);
   if (typeof bodyInput.evaluate !== "function") {
     await fillStableHaoyouValue(page, bodyInput, fallbackText, "正文");
     return { rich: false, images: 0, links: 0, plainText: fallbackText };
@@ -3240,6 +3438,10 @@ export async function insertHaoyouRichContent(page, bodyInput, article, fallback
       continue;
     }
 
+    if (options.skipImages) {
+      imageIndex += 1;
+      continue;
+    }
     let upload = payloadCache.get(item.source);
     if (!upload) {
       upload = haoyouImageUploadPayload(
@@ -3338,8 +3540,9 @@ export async function insertHaoyouRichContent(page, bodyInput, article, fallback
     if (stableChecks >= 3) break;
     await page.waitForTimeout(250);
   }
-  if (state.failedImages > 0 || state.pendingImages > 0 || state.images < content.images.length) {
-    throw new Error(`好游快爆正文图片写入不完整，预期 ${content.images.length} 张，实际 ${state.images} 张`);
+  const expectedImages = options.skipImages ? 0 : content.images.length;
+  if (state.failedImages > 0 || state.pendingImages > 0 || state.images < expectedImages) {
+    throw new Error(`好游快爆正文图片写入不完整，预期 ${expectedImages} 张，实际 ${state.images} 张`);
   }
   const expectedFragments = content.items
     .filter(item => item.type === "html" && item.plain)
@@ -3358,6 +3561,7 @@ export async function insertHaoyouRichContent(page, bodyInput, article, fallback
   return {
     rich: true,
     images: state.images,
+    ...(options.skipImages ? { imagesPending: content.images.length } : {}),
     links: state.links,
     headings: state.headings,
     formatted: state.formatted,
@@ -3372,6 +3576,51 @@ function safeProfileName(entry) {
     .slice(0, 80);
 }
 
+function browserProfileDir(entry) {
+  return path.join(os.homedir(), ".qcplay", "browser-profiles", safeProfileName(entry));
+}
+
+function browserSubmissionKey(entry, article) {
+  const source = normalizeText(article.meta?.source_url || article.payload?.source_url);
+  const content = normalizeText(article.html || article.markdown || "");
+  return createHash("sha256")
+    .update(`${entry.platformKey}\n${entry.project}\n${entry.region}\n${source}\n${article.title}\n${content}`)
+    .digest("hex");
+}
+
+async function readBrowserSubmissionState() {
+  try {
+    const value = JSON.parse(await fs.promises.readFile(BROWSER_SUBMISSION_STATE_FILE, "utf8"));
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+async function ensureBrowserSubmissionCooldown(entry, article, options) {
+  if (!options.directPublish && !options.publishDraft) return "";
+  const key = browserSubmissionKey(entry, article);
+  const previous = Number((await readBrowserSubmissionState())[key] || 0);
+  const remaining = BROWSER_SUBMISSION_COOLDOWN_MS - (Date.now() - previous);
+  if (remaining > 0) {
+    throw new Error(`${entry.platform} 同一篇文章刚刚已提交，请等待 ${Math.ceil(remaining / 1000)} 秒后再重试，避免触发平台风控或重复发布`);
+  }
+  return key;
+}
+
+async function recordBrowserSubmission(key) {
+  if (!key) return;
+  const state = await readBrowserSubmissionState();
+  state[key] = Date.now();
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const [candidate, timestamp] of Object.entries(state)) {
+    if (!Number.isFinite(Number(timestamp)) || Number(timestamp) < cutoff) delete state[candidate];
+  }
+  await fs.promises.mkdir(path.dirname(BROWSER_SUBMISSION_STATE_FILE), { recursive: true, mode: 0o700 });
+  await fs.promises.writeFile(BROWSER_SUBMISSION_STATE_FILE, `${JSON.stringify(state)}\n`, { encoding: "utf8", mode: 0o600 });
+  await fs.promises.chmod(BROWSER_SUBMISSION_STATE_FILE, 0o600).catch(() => {});
+}
+
 function isNavigationContextError(error) {
   const message = String(error?.message || error);
   return /execution context was destroyed|cannot find context with specified id|frame was detached|navigation.*interrupted/i.test(
@@ -3664,11 +3913,25 @@ async function waitForUser(message, streams = {}) {
 }
 
 function reviewApprovalAccepted(answer) {
-  return ["", "发布", "可以发布", "publish", "yes", "y"].includes(normalizeKey(answer));
+  return ["发布", "可以发布", "publish", "yes", "y"].includes(normalizeKey(answer));
 }
 
 function reviewApprovalCancelled(answer) {
-  return ["取消", "停止", "cancel", "quit", "q", "no", "n"].includes(normalizeKey(answer));
+  return ["", "取消", "停止", "cancel", "quit", "q", "no", "n"].includes(normalizeKey(answer));
+}
+
+export function draftApprovalAction(answer) {
+  const key = normalizeKey(answer);
+  if (["发布", "上线", "正式发布", "publish", "online", "yes", "y"].includes(key)) {
+    return "publish";
+  }
+  if (["保存草稿", "保存草稿箱", "保存到草稿箱", "存草稿", "保留草稿", "草稿", "keep-draft", "keepdraft", "draft"].includes(key)) {
+    return "draft";
+  }
+  if (reviewApprovalCancelled(key)) {
+    return "cancel";
+  }
+  return "";
 }
 
 async function waitForReviewApproval(message, options = {}) {
@@ -3678,7 +3941,7 @@ async function waitForReviewApproval(message, options = {}) {
     if (reviewApprovalCancelled(answer)) {
       throw new Error("用户已取消正式发布，草稿未提交");
     }
-    throw new Error(`无法识别草稿确认输入“${answer}”，请输入“可以发布”或直接回车`);
+    throw new Error(`无法识别草稿确认输入“${answer}”，请输入“可以发布”或“取消”`);
   }
   const input = options.streams?.input || process.stdin;
   const output = options.streams?.output || process.stdout;
@@ -3690,13 +3953,13 @@ async function waitForReviewApproval(message, options = {}) {
     for (;;) {
       const answer = await question(
         rl,
-        `${message}\n输入“可以发布”或直接按 Enter 继续，输入“取消”停止: `
+        `${message}\n输入“可以发布”继续；直接按 Enter 默认取消，输入“取消”停止: `
       );
       if (reviewApprovalAccepted(answer)) return;
       if (reviewApprovalCancelled(answer)) {
         throw new Error("用户已取消正式发布，草稿未提交");
       }
-      output.write("无法识别输入，请输入“可以发布”、直接按 Enter 或输入“取消”。\n");
+      output.write("无法识别输入，请输入“可以发布”或“取消”（直接按 Enter 会取消）。\n");
     }
   } finally {
     rl.close();
@@ -3708,6 +3971,19 @@ async function waitForReviewApproval(message, options = {}) {
  * This is intentionally separate from publishWithBrowser so page structure and login
  * flows can be checked against the real site before running an article publish.
  */
+async function releaseAwaitingActionBrowser(page) {
+  const context = typeof page?.context === "function" ? page.context() : null;
+  if (typeof context?.__qcplayDetach !== "function") {
+    return;
+  }
+  await context.__qcplayDetach();
+}
+
+async function awaitingActionResult(page, result) {
+  await releaseAwaitingActionBrowser(page);
+  return result;
+}
+
 export async function openPublishPage(entry, options = {}) {
   const spec = BROWSER_PLATFORM_SPECS[entry.platformKey];
   if (!spec || entry.publisher !== "browser") {
@@ -3718,13 +3994,21 @@ export async function openPublishPage(entry, options = {}) {
     throw new Error(`${entry.platform} 配置缺少发布页面 URL`);
   }
 
-  const context = options.context || (await launchBrowserContext(entry, options.browserChannel));
+  const context = options.context || (await launchBrowserContext(entry, options.browserChannel, options));
   const ownsContext = !options.context;
   try {
     const page = context.pages()[0] || (await context.newPage());
     await page.goto(editorUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
     await afterNavigation(page);
     options.onProgress?.(`已打开真实${entry.platform}发布页面: ${page.url()}`);
+    if (options.awaitAIAction) {
+      return awaitingActionResult(page, {
+        url: page.url(),
+        status: "awaiting_action",
+        approvalRequired: true,
+        approvalActions: ["publish", "save_draft", "cancel"]
+      });
+    }
     const prompt = options.waitForUser || (message => waitForUser(message, options.streams));
     const promptMessage = options.accountSwitch
       ? `${entry.platform}账号切换页面已打开。请在浏览器中完成账号切换，确认当前账号正确后按 Enter 继续后续发布流程`
@@ -3732,22 +4016,32 @@ export async function openPublishPage(entry, options = {}) {
     await prompt(promptMessage);
     return { url: page.url(), status: "opened" };
   } finally {
-    if (ownsContext) {
-      await context.close().catch(() => {});
+    if (ownsContext && !options.awaitAIAction) {
+      await closeBrowserContext(context);
     }
   }
 }
 
 async function reviewPreparedDraft(page, entry, options) {
   if (!options.reviewDraft) {
-    return;
+    return null;
   }
   await page.waitForTimeout(500);
+  if (options.awaitAIAction) {
+    options.onProgress?.(`${entry.platform} 标题和正文已填入，正在等待 AI 对话授权`);
+    return awaitingActionResult(page, {
+      url: page.url(),
+      status: "awaiting_action",
+      approvalRequired: true,
+      approvalActions: ["publish", "save_draft", "cancel"]
+    });
+  }
   await waitForReviewApproval(
     `${entry.platform} 待发布稿已准备，请在浏览器中预览标题、正文、图片和发布设置`,
     options
   );
   options.onProgress?.(`${entry.platform} 草稿预览已确认，正在正式发布`);
+  return null;
 }
 
 async function editorIsReady(page, spec) {
@@ -4379,16 +4673,16 @@ async function uploadTapTapCover(page, source, articleFile) {
 
 async function publishTapTap(page, entry, article, spec, options, promptUser) {
   let preparedArticle = prepareTapTapArticleForProject(article, entry);
-  const settings = resolveTapTapPublishingOptions(preparedArticle, entry);
+  const settings = {
+    ...resolveTapTapPublishingOptions(preparedArticle, entry),
+    ...(options.draftOnly ? { draft: true, scheduled: "" } : {})
+  };
   const titleLimit = settings.type === "moment" ? 20 : 30;
-  if (preparedArticle.title.length > titleLimit) {
-    if (normalizeText(entry.project) === "迷途之光" && settings.type === "moment") {
-      preparedArticle.title = Array.from(preparedArticle.title).slice(0, titleLimit).join("");
-    } else {
-      throw new Error(
-        `TapTap ${settings.typeLabel}标题最多 ${titleLimit} 个字符，当前为 ${preparedArticle.title.length} 个字符`
-      );
-    }
+  preparedArticle = { ...preparedArticle, title: resolveTapTapTitle(preparedArticle, titleLimit) };
+  if (Array.from(preparedArticle.title).length > titleLimit) {
+    throw new Error(
+      `TapTap ${settings.typeLabel}标题最多 ${titleLimit} 个字符，当前为 ${Array.from(preparedArticle.title).length} 个字符`
+    );
   }
   const richContent = buildTapTapRichContent(preparedArticle);
   const body = richContent.plainText || plainTextForPlatform(preparedArticle, "taptap");
@@ -4413,7 +4707,14 @@ async function publishTapTap(page, entry, article, spec, options, promptUser) {
   if (!(await waitForEditorReady(page, () => tapTapCreatorReady(page, spec), 15000))) {
     throw new Error("TapTap 登录完成后仍未进入创作者发布页，请确认账号拥有发布权限");
   }
-  await resumeMatchingTapTapDraft(page, spec, preparedArticle.title, editorUrl);
+  const resumedDraft = await resumeMatchingTapTapDraft(page, spec, preparedArticle.title, editorUrl);
+  if (options.publishDraft) {
+    if (!resumedDraft) {
+      throw new Error("未找到标题匹配的 TapTap 草稿，已停止以避免重新写入内容");
+    }
+    const confirmation = await submitTapTap(page, { ...settings, draft: false, scheduled: "" }, options, promptUser);
+    return { url: page.url(), status: "published", type: settings.type, resumedDraft: true, ...confirmation };
+  }
 
   if (settings.type === "moment") {
     const imageSources = settings.images.length
@@ -4450,9 +4751,54 @@ async function publishTapTap(page, entry, article, spec, options, promptUser) {
   await applyTapTapForum(page, settings.forum, promptUser, { project: entry.project });
   await applyTapTapSchedule(page, settings.scheduled, promptUser);
   if (!settings.draft) {
-    await reviewPreparedDraft(page, entry, options);
+    const review = await reviewPreparedDraft(page, entry, options);
+    if (review) {
+      return { ...review, type: settings.type };
+    }
   }
   const confirmation = await submitTapTap(page, settings, options, promptUser);
+  if (options.draftOnly) {
+    return {
+      url: page.url(),
+      status: "draft",
+      type: settings.type,
+      draftOnly: true,
+      approvalRequired: true,
+      approvalActions: ["publish", "cancel"],
+      ...confirmation
+    };
+  }
+  if (settings.draft && typeof options.waitForDraftApproval === "function") {
+    const answer = await options.waitForDraftApproval(
+      "TapTap 草稿已保存，页面保持打开。请选择“发布/上线”“保存草稿”或“取消”"
+    );
+    const action = draftApprovalAction(answer);
+    if (action === "publish") {
+      const publishConfirmation = await submitTapTap(
+        page,
+        { ...settings, draft: false },
+        { ...options, reviewDraft: false, directPublish: true },
+        promptUser
+      );
+      return {
+        url: page.url(),
+        status: "published",
+        type: settings.type,
+        draftConfirmation: confirmation.confirmation || "response",
+        ...publishConfirmation
+      };
+    }
+    if (!action) {
+      throw new Error(`无法识别草稿授权“${normalizeText(answer)}”，请选择发布、保存草稿或取消`);
+    }
+    return {
+      url: page.url(),
+      status: "draft",
+      type: settings.type,
+      draftApproval: action,
+      ...confirmation
+    };
+  }
   if (options.keepOpen) {
     await promptUser(
       `TapTap ${settings.draft ? "草稿保存" : settings.scheduled ? "定时发布" : "发布"}已收到成功回执，浏览器保持打开供检查`
@@ -4801,9 +5147,63 @@ async function submitBilibili(page, spec, settings, article, metadataApplied, op
   }
 }
 
+async function preparedBilibiliArticleState(page, spec, settings, article) {
+  if (settings.type !== "article") return null;
+  if (!(await waitForEditorReady(page, () => bilibiliEditorIsReady(page, spec, settings), 1000))) return null;
+  const titleInput = await waitForVisible(page, spec.title, 1000);
+  const bodyInput = await waitForVisible(page, spec.body, 1000);
+  if (!titleInput || !bodyInput) return null;
+  const title = normalizeText(
+    typeof titleInput.inputValue === "function"
+      ? await titleInput.inputValue().catch(() => "")
+      : typeof titleInput.innerText === "function"
+        ? await titleInput.innerText().catch(() => "")
+        : ""
+  );
+  if (title !== normalizeText(article.title)) return null;
+
+  const content = buildBilibiliRichContent(article);
+  const state = await bodyInput
+    .evaluate(element => ({
+      text: element.innerText,
+      images: element.querySelectorAll("img").length,
+      failedImages: element.querySelectorAll('.upload-fail, .image-upload-error, [class*="upload-error"]').length,
+      links: [...element.querySelectorAll("a[href]")].map(link => link.href)
+    }))
+    .catch(() => null);
+  if (!state || state.failedImages > 0 || state.images < content.images.length) return null;
+  const actualText = normalizedPresenceText(state.text);
+  if (content.items.some(item => item.type === "html" && item.plain && !actualText.includes(normalizedPresenceText(item.plain)))) {
+    return null;
+  }
+  const actualLinks = new Set(state.links.map(safeTapTapHref));
+  if (content.links.some(link => !actualLinks.has(link.href))) return null;
+  return {
+    richContent: { rich: true, images: state.images, links: content.links.length, plainText: content.plainText },
+    metadataApplied: { category: true, tags: true, topic: true, cover: true }
+  };
+}
+
 async function publishBilibili(page, entry, article, spec, options, promptUser) {
   const settings = resolveBilibiliPublishingOptions(article, entry);
   const editorUrl = browserPlatformPageUrl(entry, settings.type);
+  if (options.directPublish) {
+    const prepared = await preparedBilibiliArticleState(page, spec, settings, article);
+    if (!prepared) {
+      throw new Error("B站待发布编辑页未找到与当前文章一致的已准备内容；请重新准备后再授权发布");
+    }
+    options.onProgress?.("已复用 B站 待发布内容，正在提交，不重复上传正文图片或封面");
+    const confirmation = await submitBilibili(
+      page,
+      spec,
+      settings,
+      article,
+      prepared.metadataApplied,
+      options,
+      promptUser
+    );
+    return { url: page.url(), status: "published", type: settings.type, ...prepared.richContent, ...confirmation };
+  }
   await page.goto(editorUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
   await afterNavigation(page);
   if (!(await waitForEditorReady(page, () => bilibiliEditorIsReady(page, spec, settings)))) {
@@ -4836,8 +5236,16 @@ async function publishBilibili(page, entry, article, spec, options, promptUser)
   await validateBilibiliFieldLength(bodyInput, body, settings.type === "video" ? "简介" : "正文");
   await fillLocator(titleInput, article.title);
   await verifyFilledValue(titleInput, article.title, "标题", "B站");
-  if (settings.type === "article") {
-    await insertBilibiliRichContent(page, bodyInput, article, spec, body, {
+  let richContent = null;
+  if (options.previewTextOnly) {
+    richContent = await insertBilibiliRichContent(page, bodyInput, article, spec, body, {
+      skipImages: settings.type === "article",
+      previewOnly: true,
+      onProgress: options.onProgress
+    });
+  } else if (settings.type === "article") {
+    richContent = await insertBilibiliRichContent(page, bodyInput, article, spec, body, {
+      onProgress: options.onProgress,
       removeNoncompliant: normalizeText(entry.project) === "最强蜗牛"
     });
   } else {
@@ -4848,9 +5256,27 @@ async function publishBilibili(page, entry, article, spec, options, promptUser)
 
   const metadataApplied =
     settings.type === "article"
-      ? await applyBilibiliMetadata(page, spec, settings, article, true)
+      ? options.previewTextOnly
+        ? { category: false, tags: false, topic: false, cover: false, deferred: true }
+        : await applyBilibiliMetadata(page, spec, settings, article, true)
       : { category: true, tags: true, topic: true, cover: true };
-  await reviewPreparedDraft(page, entry, options);
+  if (!options.draftOnly) {
+    const review = await reviewPreparedDraft(page, entry, options);
+    if (review) {
+      return { ...review, type: settings.type, metadataApplied, ...richContent };
+    }
+  }
+  if (options.draftOnly) {
+    return {
+      url: page.url(),
+      status: "draft",
+      type: settings.type,
+      draftOnly: true,
+      approvalRequired: true,
+      approvalActions: ["publish", "cancel"],
+      metadataApplied
+    };
+  }
   const confirmation = await submitBilibili(page, spec, settings, article, metadataApplied, options, promptUser);
   if (options.keepOpen) {
     await promptUser(`B站${settings.typeLabel}投稿已收到成功回执，浏览器保持打开供检查`);
@@ -5147,6 +5573,7 @@ async function uploadWeiboArticleInlineImage(page, bodyInput, spec, payload, sou
   } while (true);
 
   let uploadedPreview = previews.last();
+  let candidateIndexes = [];
   if (previousPreviewKeys.length > 0 && typeof previews.evaluateAll === "function") {
     const previewKeys = await previews
       .evaluateAll(elements =>
@@ -5156,10 +5583,20 @@ async function uploadWeiboArticleInlineImage(page, bodyInput, spec, payload, sou
         })
       )
       .catch(() => []);
-    const uploadedIndex = previewKeys.findIndex(key => key && !previousPreviewKeys.includes(key));
-    if (uploadedIndex >= 0) {
-      uploadedPreview = previews.nth(uploadedIndex);
-    }
+    candidateIndexes = previewKeys
+      .map((key, index) => (key && !previousPreviewKeys.includes(key) ? index : -1))
+      .filter(index => index >= 0);
+  }
+  const previewCount = await previews.count().catch(() => 0);
+  if (candidateIndexes.length === 0 && previewCount > previousPreviews) {
+    candidateIndexes = Array.from({ length: previewCount - previousPreviews }, (_, offset) => previousPreviews + offset);
+  }
+  if (candidateIndexes.length === 0 && previewCount > 0) {
+    candidateIndexes = [previewCount - 1];
+  }
+  if (structuredLibrary && candidateIndexes.length > 0) {
+    // Let the common click-and-verify path below perform the selection once.
+    uploadedPreview = previews.nth(candidateIndexes[0]);
   }
   if ((await uploadedPreview.count()) > 0 && (await uploadedPreview.isVisible().catch(() => false))) {
     await uploadedPreview.click();
@@ -6064,8 +6501,8 @@ async function publishWeibo(page, entry, article, spec, options, promptUser) {
   if (!body) {
     throw new Error("微博文章正文不能为空");
   }
-  if (title.length > 32) {
-    throw new Error(`微博文章标题最多 32 个字符，当前为 ${title.length} 个字符`);
+  if (Array.from(title).length > 32) {
+    throw new Error(`微博文章标题最多 32 个字符，当前为 ${Array.from(title).length} 个字符`);
   }
 
   const editorUrl = weiboArticleEditorUrl(entry.url);
@@ -6109,7 +6546,26 @@ async function publishWeibo(page, entry, article, spec, options, promptUser) {
     throw new Error("微博文章“下一步”按钮不可用，请检查标题、正文和封面设置");
   }
 
-  await reviewPreparedDraft(page, entry, options);
+  if (!options.draftOnly) {
+    const review = await reviewPreparedDraft(page, entry, options);
+    if (review) {
+      return { ...review, type: "article", title, ...richContent, ...cover, column };
+    }
+  }
+  if (options.draftOnly) {
+    return {
+      url: page.url(),
+      status: "draft",
+      type: "article",
+      title,
+      draftOnly: true,
+      approvalRequired: true,
+      approvalActions: ["publish", "cancel"],
+      ...richContent,
+      ...cover,
+      column
+    };
+  }
   const initialUrl = page.url();
   progress("正在进入发布确认页");
   let submitButton = null;
@@ -6197,7 +6653,7 @@ async function publishWeibo(page, entry, article, spec, options, promptUser) {
     if (options.keepOpen) {
       await promptUser("微博头条文章已收到发布成功回执，浏览器保持打开供检查");
     }
-    return { url: page.url(), status: "published", type: "article", ...richContent, ...cover, column, ...confirmation };
+    return { url: page.url(), status: "published", type: "article", title, ...richContent, ...cover, column, ...confirmation };
   }
   throw new Error("微博发布确认页中未找到最终发布按钮");
 }
@@ -6238,7 +6694,10 @@ async function publishWeiboQuick(page, entry, article, options, promptUser) {
   await fillLocator(bodyInput, body);
   const submit = await waitForVisibleButton(page, [/^发送$/, /^发布$/], 5000);
   if (!submit) throw new Error("微博快捷发布页面中未找到发送按钮");
-  await reviewPreparedDraft(page, entry, options);
+  const review = await reviewPreparedDraft(page, entry, options);
+  if (review) {
+    return { ...review, type: "quick" };
+  }
   await submit.click();
   await page.waitForTimeout(1500);
   return { url: page.url(), status: "published", type: "quick" };
@@ -6248,8 +6707,56 @@ async function publishXiaohongshu(page, entry, article, spec, options, promptUse
   const editorUrl = browserPlatformPageUrl(entry);
   await page.goto(editorUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
   await afterNavigation(page);
-  const publishing = resolveXiaohongshuPublishingOptions(article);
   const body = buildTapTapRichContent(article).plainText || plainTextForPlatform(article, "xiaohongshu");
+  let publishing;
+  try {
+    publishing = resolveXiaohongshuPublishingOptions(article);
+  } catch (error) {
+    if (!options.previewTextOnly) throw error;
+    publishing = {
+      images: [],
+      collection: "",
+      imageSource: "unavailable",
+      validationError: error.message || String(error)
+    };
+  }
+
+  // Kept for callers that deliberately ask for a text-only editor inspection.
+  // Standard AI authorisation never uses this path: it waits for all images and
+  // the editor readback before offering an action.
+  if (options.previewTextOnly) {
+    const titleInput = await waitForVisible(page, spec.title, 1000);
+    const bodyInput = await waitForVisible(page, spec.body, 1000);
+    const titleFits = Array.from(article.title).length <= 20;
+    const bodyFits = Array.from(body).length <= 1000;
+    if (titleInput && bodyInput && titleFits && bodyFits) {
+      await fillLocator(titleInput, article.title);
+      await fillLocator(bodyInput, body);
+      options.onProgress?.("小红书 标题和正文已填入，正在等待 AI 对话授权");
+      return awaitingActionResult(page, {
+        url: page.url(),
+        status: "awaiting_action",
+        approvalRequired: true,
+        approvalActions: ["publish", "save_draft", "cancel"],
+        contentPrepared: true,
+        imagesPending: publishing.images.length,
+        type: "note",
+        ...publishing
+      });
+    }
+    options.onProgress?.("小红书需要先上传图片才能进入笔记编辑器；页面已打开，正在等待 AI 对话授权");
+    return awaitingActionResult(page, {
+      url: page.url(),
+      status: "awaiting_action",
+      approvalRequired: true,
+      approvalActions: ["publish", "save_draft", "cancel"],
+      contentPrepared: false,
+      requiresMediaBeforeText: true,
+      imagesPending: publishing.images.length,
+      type: "note",
+      ...publishing
+    });
+  }
   if (Array.from(body).length > 1000) {
     throw new Error(`小红书正文最多 1000 个字符，当前为 ${Array.from(body).length} 个字符；请先精简内容后再发布`);
   }
@@ -6277,12 +6784,20 @@ async function publishXiaohongshu(page, entry, article, spec, options, promptUse
   }
   options.onProgress?.(`正在上传小红书图片 ${payloads.length} 张`);
   await imageInput.setInputFiles(payloads);
-  await waitForUploadsSettled(page, "小红书图片", 120000);
+  await waitForUploadsSettled(page, "小红书图片", 120000).catch(error => {
+    // The creator can replace the uploader with a new note-editor tab as soon
+    // as the cover is accepted. The editor lookup below owns that transition.
+    if (!/Target page, context or browser has been closed/i.test(String(error?.message || error))) {
+      throw error;
+    }
+  });
   options.onProgress?.("图片上传完成，正在填写笔记内容");
 
-  if (!(await waitForEditorReady(page, () => editorIsReady(page, spec), 120000))) {
+  const editorPage = await waitForXiaohongshuEditorPage(page, spec, 120000);
+  if (!editorPage) {
     throw new Error("小红书图片上传完成后未进入笔记编辑器，请检查图片格式或账号发布权限");
   }
+  page = editorPage;
   const titleInput = await waitForVisible(page, spec.title, 8000);
   const bodyInput = await waitForVisible(page, spec.body, 8000);
   if (!titleInput || !bodyInput) throw new Error("小红书发布编辑器未找到标题或正文控件");
@@ -6316,11 +6831,25 @@ async function publishXiaohongshu(page, entry, article, spec, options, promptUse
   if (typeof submit.isDisabled === "function" && await submit.isDisabled().catch(() => false)) {
     throw new Error("小红书发布按钮不可用，请检查正文和图片上传状态");
   }
+  if (options.draftOnly) {
+    return {
+      url: page.url(),
+      status: "draft",
+      draftOnly: true,
+      approvalRequired: true,
+      approvalActions: ["publish", "cancel"],
+      type: "note",
+      ...publishing
+    };
+  }
   if (options.keepOpen && !isInteractiveTerminal(options.streams)) {
     options.onProgress?.("小红书待发布内容已准备完成，请在浏览器中核对后手动点击“发布”；程序将等待并验证发布结果");
     return waitForManualXiaohongshuSubmission(page, 600000);
   }
-  await reviewPreparedDraft(page, entry, options);
+  const review = await reviewPreparedDraft(page, entry, options);
+  if (review) {
+    return { ...review, type: "note", ...publishing };
+  }
   const initialUrl = page.url();
   const mutationPromise =
     typeof page.waitForResponse === "function"
@@ -6331,6 +6860,32 @@ async function publishXiaohongshu(page, entry, article, spec, options, promptUse
   return { url: page.url(), status: "published", type: "note", ...publishing, ...confirmation };
 }
 
+async function waitForXiaohongshuEditorPage(initialPage, spec, timeoutMs) {
+  const context = typeof initialPage?.context === "function" ? initialPage.context() : null;
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const candidates = [initialPage, ...(typeof context?.pages === "function" ? context.pages() : [])]
+      .filter((candidate, index, pages) => candidate && pages.indexOf(candidate) === index)
+      .filter(candidate => !(typeof candidate.isClosed === "function" && candidate.isClosed()));
+    for (const candidate of candidates) {
+      try {
+        if (await editorIsReady(candidate, spec)) return candidate;
+      } catch (error) {
+        if (!/Target page, context or browser has been closed/i.test(String(error?.message || error))) {
+          throw error;
+        }
+      }
+    }
+    const waitPage = candidates[0];
+    if (waitPage?.waitForTimeout) {
+      await waitPage.waitForTimeout(300).catch(() => {});
+    } else {
+      await new Promise(resolve => setTimeout(resolve, 300));
+    }
+  } while (Date.now() < deadline);
+  return null;
+}
+
 function isInteractiveTerminal(streams = {}) {
   const input = streams.input || process.stdin;
   const output = streams.output || process.stdout;
@@ -6367,11 +6922,64 @@ async function waitForManualXiaohongshuSubmission(page, timeoutMs) {
   throw new Error("小红书待发布页面等待超时，未检测到手动发布成功回执");
 }
 
-function xiaohongshuMutationResponse(response) {
+export function xiaohongshuMutationResponse(response) {
   const request = response.request();
   if (!/^(?:POST|PUT|PATCH)$/i.test(request.method())) return false;
   const url = response.url();
-  return /xiaohongshu\.com/i.test(url) && /(?:publish|note|feed|create|upload)/i.test(url);
+  if (!/xiaohongshu\.com/i.test(url)) return false;
+  // Media transfers can still finish after the user presses Publish. They are
+  // not proof that a note was created and must never satisfy this wait.
+  if (/(?:^|[./-])(?:ros-)?upload(?:[./-]|$)/i.test(url)) return false;
+  return /(?:publish|note|feed|create)/i.test(url);
+}
+
+export function xiaohongshuPublishedReceipt(payload = {}) {
+  const data = payload?.data || {};
+  const note = data?.note || payload?.note || {};
+  const publishedUrl = [
+    payload?.published_url,
+    payload?.publishedUrl,
+    payload?.note_url,
+    payload?.noteUrl,
+    payload?.share_url,
+    payload?.shareUrl,
+    data?.published_url,
+    data?.publishedUrl,
+    data?.note_url,
+    data?.noteUrl,
+    data?.share_url,
+    data?.shareUrl,
+    note?.url,
+    note?.share_url,
+    note?.shareUrl
+  ]
+    .map(normalizeText)
+    .find(value => {
+      try {
+        const url = new URL(value);
+        return /(?:^|\.)xiaohongshu\.com$/i.test(url.hostname) && !/^creator\./i.test(url.hostname);
+      } catch {
+        return false;
+      }
+    }) || "";
+  const noteId = [
+    payload?.note_id,
+    payload?.noteId,
+    payload?.id,
+    data?.note_id,
+    data?.noteId,
+    data?.id,
+    note?.note_id,
+    note?.noteId,
+    note?.id
+  ]
+    .map(normalizeText)
+    .find(Boolean) || "";
+  if (!publishedUrl && !noteId) return null;
+  return {
+    noteId,
+    publishedUrl: publishedUrl || `https://www.xiaohongshu.com/explore/${encodeURIComponent(noteId)}`
+  };
 }
 
 async function waitForXiaohongshuSubmission(page, initialUrl, mutationPromise, options) {
@@ -6382,7 +6990,11 @@ async function waitForXiaohongshuSubmission(page, initialUrl, mutationPromise, o
     if (response.status() >= 400 || payload?.success === false || Number(payload?.code) > 0) {
       throw new Error(`小红书发布失败: ${normalizeText(payload?.msg || payload?.message || `接口状态 ${response.status()}`)}`);
     }
-    return { confirmation: "response", responseUrl: response.url() };
+    const receipt = xiaohongshuPublishedReceipt(payload);
+    if (!receipt) {
+      throw new Error("小红书发布结果未返回笔记 ID 或公开笔记链接，无法确认发布记录");
+    }
+    return { confirmation: "response", responseUrl: response.url(), ...receipt };
   }
   const deadline = Date.now() + 15000;
   do {
@@ -6390,19 +7002,229 @@ async function waitForXiaohongshuSubmission(page, initialUrl, mutationPromise, o
     if (/发布失败|上传失败|内容违规|请重试/.test(pageText)) {
       throw new Error(`小红书发布失败: ${normalizeText(pageText.match(/(?:发布失败|上传失败|内容违规)[^\n]*/)?.[0] || "页面返回失败提示")}`);
     }
-    if (/发布成功|笔记发布成功|发布完成/.test(pageText) || page.url() !== initialUrl) {
-      return { confirmation: "page" };
+    if (/发布成功|笔记发布成功|发布完成/.test(pageText)) {
+      throw new Error("小红书页面提示发布完成，但未返回笔记 ID 或公开笔记链接，无法确认发布记录");
     }
     await page.waitForTimeout(500);
   } while (Date.now() < deadline);
   throw new Error("小红书发布后未检测到成功回执");
 }
 
-async function launchBrowserContext(entry, browserChannel) {
+async function findAvailableLoopbackPort() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(error => (error ? reject(error) : resolve(address.port)));
+    });
+  });
+}
+
+async function readCdpVersion(port) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(
+      { host: "127.0.0.1", port, path: "/json/version", timeout: 1500 },
+      response => {
+        let payload = "";
+        response.setEncoding("utf8");
+        response.on("data", chunk => {
+          payload += chunk;
+        });
+        response.on("end", () => {
+          try {
+            const parsed = JSON.parse(payload);
+            if (parsed.webSocketDebuggerUrl) {
+              resolve(parsed.webSocketDebuggerUrl);
+              return;
+            }
+            reject(new Error("调试端点未返回 WebSocket 地址"));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      }
+    );
+    request.once("error", reject);
+    request.once("timeout", () => request.destroy(new Error("调试端点请求超时")));
+  });
+}
+
+async function waitForCdpEndpoint(port, timeoutMs = 15000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  do {
+    try {
+      return await readCdpVersion(port);
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 150));
+    }
+  } while (Date.now() < deadline);
+  throw new Error(`浏览器调试会话启动超时：${lastError?.message || "未返回调试端点"}`);
+}
+
+async function resolveDetachedBrowserExecutable(channel) {
+  if (process.platform !== "win32") {
+    return "";
+  }
+  const normalizedChannel = normalizeKey(channel || "msedge");
+  const programFiles = [process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean);
+  const product = /chrome/.test(normalizedChannel) ? ["Google", "Chrome", "Application", "chrome.exe"] : ["Microsoft", "Edge", "Application", "msedge.exe"];
+  const candidates = [process.env.QCPLAY_BROWSER_EXECUTABLE, ...programFiles.map(root => path.join(root, ...product))].filter(Boolean);
+  for (const candidate of candidates) {
+    if (await fs.promises.access(candidate, fs.constants.X_OK).then(() => true).catch(() => false)) {
+      return candidate;
+    }
+  }
+  return "";
+}
+
+async function launchDetachedBrowserContext(profileDir, channel) {
+  const executable = await resolveDetachedBrowserExecutable(channel);
+  if (!executable) {
+    throw new Error("未找到可分离的 Edge/Chrome 浏览器，无法在保留编辑页的同时返回 AI 授权事件");
+  }
+  let lastError;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const port = await findAvailableLoopbackPort();
+    const child = spawn(
+      executable,
+      [
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--remote-debugging-address=127.0.0.1",
+        "--remote-allow-origins=http://localhost,http://127.0.0.1",
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${profileDir}`
+      ],
+      { detached: true, stdio: "ignore", windowsHide: true }
+    );
+    child.unref();
+    try {
+      const endpoint = await waitForCdpEndpoint(port);
+      const { chromium } = await import("playwright-core");
+      const browser = await chromium.connectOverCDP(endpoint);
+      const context = browser.contexts()[0];
+      if (!context) {
+        await browser.close().catch(() => {});
+        throw new Error("浏览器调试会话未返回默认上下文");
+      }
+      await saveDetachedBrowserSession(profileDir, endpoint);
+      attachDetachedBrowserContext(context, browser, profileDir);
+      return context;
+    } catch (error) {
+      lastError = error;
+      child.kill();
+      if (attempt < 2) {
+        await new Promise(resolve => setTimeout(resolve, 300));
+      }
+    }
+  }
+  throw lastError;
+}
+
+function detachedBrowserSessionFile(profileDir) {
+  return path.join(profileDir, ".qcplay-detached-session.json");
+}
+
+async function saveDetachedBrowserSession(profileDir, endpoint) {
+  const sessionFile = detachedBrowserSessionFile(profileDir);
+  await fs.promises.writeFile(
+    sessionFile,
+    `${JSON.stringify({ endpoint, createdAt: new Date().toISOString() })}\n`,
+    { encoding: "utf8", mode: 0o600 }
+  );
+}
+
+async function loadDetachedBrowserSession(profileDir) {
+  const sessionFile = detachedBrowserSessionFile(profileDir);
+  try {
+    const session = JSON.parse(await fs.promises.readFile(sessionFile, "utf8"));
+    if (
+      typeof session?.endpoint !== "string" ||
+      !/^(?:http|ws):\/\/127\.0\.0\.1:\d+(?:\/devtools\/browser\/[^/]+)?\/?$/i.test(session.endpoint)
+    ) {
+      throw new Error("无效的调试会话地址");
+    }
+    return { ...session, sessionFile };
+  } catch {
+    return null;
+  }
+}
+
+async function removeDetachedBrowserSession(profileDir) {
+  await fs.promises.unlink(detachedBrowserSessionFile(profileDir)).catch(() => {});
+}
+
+function attachDetachedBrowserContext(context, browser, profileDir) {
+  Object.defineProperty(context, "__qcplayDetach", {
+    // `browser.close()` sends a Browser.close command over CDP.  A detached
+    // session is owned by the user-facing Edge process, so only close the
+    // Playwright transport and leave that editor window intact.
+    value: async () => {
+      if (typeof browser?._connection?.close === "function") {
+        browser._connection.close();
+        return;
+      }
+      // Older Playwright builds do not expose a public disconnect method.
+      // Do not fall back to browser.close(), which would close the editor.
+      if (typeof browser?.disconnect === "function") {
+        await browser.disconnect();
+      }
+    },
+    enumerable: false
+  });
+  Object.defineProperty(context, "__qcplayDetachedProfileDir", {
+    value: profileDir,
+    enumerable: false
+  });
+  return context;
+}
+
+async function reconnectDetachedBrowserContext(profileDir, chromium) {
+  const savedSession = await loadDetachedBrowserSession(profileDir);
+  const endpoint = normalizeText(process.env.QCPLAY_BROWSER_CDP_ENDPOINT) || savedSession?.endpoint;
+  if (!endpoint || !/^(?:http|ws):\/\/127\.0\.0\.1:\d+(?:\/devtools\/browser\/[^/]+)?\/?$/i.test(endpoint)) {
+    return null;
+  }
+  try {
+    const browser = await chromium.connectOverCDP(endpoint);
+    const context = browser.contexts()[0];
+    if (!context) {
+      await browser.close().catch(() => {});
+      throw new Error("浏览器调试会话未返回默认上下文");
+    }
+    return attachDetachedBrowserContext(context, browser, profileDir);
+  } catch {
+    if (savedSession) {
+      await removeDetachedBrowserSession(profileDir);
+    }
+    return null;
+  }
+}
+
+async function closeBrowserContext(context) {
+  if (typeof context?.__qcplayDetach === "function") {
+    await context.__qcplayDetach().catch(() => {});
+    return;
+  }
+  await context?.close?.().catch(() => {});
+}
+
+async function launchBrowserContext(entry, browserChannel, options = {}) {
   const { chromium } = await import("playwright-core");
-  const profileDir = path.join(os.homedir(), ".qcplay", "browser-profiles", safeProfileName(entry));
+  const profileDir = browserProfileDir(entry);
   await fs.promises.mkdir(profileDir, { recursive: true, mode: 0o700 });
   const channel = browserChannel || process.env.QCPLAY_BROWSER_CHANNEL || (process.platform === "win32" ? "msedge" : "chrome");
+  if (options.awaitAIAction) {
+    return launchDetachedBrowserContext(profileDir, channel);
+  }
+  const detachedContext = await reconnectDetachedBrowserContext(profileDir, chromium);
+  if (detachedContext) {
+    options.onProgress?.(`已复用当前 ${entry.platform} 授权编辑页，继续执行已确认的动作`);
+    return detachedContext;
+  }
   return chromium.launchPersistentContext(profileDir, {
     channel,
     headless: false,
@@ -6559,7 +7381,7 @@ export async function publishWithBrowser(entry, article, options = {}) {
   }
 
   const contentPolicy = resolvePlatformContentRequirements(entry);
-  if (contentPolicy.optionalSectionReview && !options.reviewDraft && !options.directPublish) {
+  if (contentPolicy.optionalSectionReview && !options.reviewDraft && !options.directPublish && !options.draftOnly) {
     options = { ...options, reviewDraft: true };
     options.onProgress?.(
       `${entry.platform} 的飞书特殊要求包含可选删除板块，已切换为发布前人工预览确认`
@@ -6574,7 +7396,7 @@ export async function publishWithBrowser(entry, article, options = {}) {
 
   const body =
     entry.platformKey === "haoyou"
-      ? buildHaoyouRichContent(preparedArticle).plainText || plainTextForPlatform(preparedArticle, entry.platformKey)
+      ? buildHaoyouPublishRichContent(preparedArticle).plainText || plainTextForPlatform(preparedArticle, entry.platformKey)
       : plainTextForPlatform(preparedArticle, entry.platformKey);
   if (entry.platformKey === "x" && body.length > 280) {
     throw new Error(`X 内容共 ${body.length} 个字符，超过 280 字符限制`);
@@ -6584,11 +7406,12 @@ export async function publishWithBrowser(entry, article, options = {}) {
   }
 
   const ownsContext = !options.context;
-  const context = options.context || (await launchBrowserContext(entry, options.browserChannel));
+  const context = options.context || (await launchBrowserContext(entry, options.browserChannel, options));
   const pages = context.pages();
   const page = pages[0] || (await context.newPage());
   const promptUser = options.waitForUser || (message => waitForUser(message, options.streams));
   let haoyouEditorOpened = false;
+  let preserveEditorOnFailure = false;
   try {
     if (entry.platformKey === "taptap") {
       return await publishTapTap(page, entry, preparedArticle, spec, options, promptUser);
@@ -6654,7 +7477,18 @@ export async function publishWithBrowser(entry, article, options = {}) {
     }
     let richContent = null;
     if (entry.platformKey === "haoyou") {
-      richContent = await insertHaoyouRichContent(page, bodyInput, preparedArticle, body);
+      if (options.previewTextOnly) {
+        await fillStableHaoyouValue(page, bodyInput, body, "正文");
+        richContent = {
+          rich: false,
+          images: 0,
+          imagesPending: buildHaoyouPublishRichContent(preparedArticle).images.length,
+          links: 0,
+          plainText: body
+        };
+      } else {
+        richContent = await insertHaoyouRichContent(page, bodyInput, preparedArticle, body);
+      }
     } else {
       await fillLocator(bodyInput, body);
     }
@@ -6665,10 +7499,22 @@ export async function publishWithBrowser(entry, article, options = {}) {
       if (entry.platformKey === "haoyou" && (await firstVisible(page, [".editSubmit"]))) {
         throw new Error("好游快爆标题和正文已写入，但发布按钮仍不可用，请检查发布设置");
       }
-      await promptUser(`${entry.platform} 页面中未找到发布按钮，正文已填入，请检查并手动发布`);
-      return { url: page.url(), manualSubmit: true };
+      throw new Error(`${entry.platform} 页面中未找到发布按钮，正文已填入但尚未满足提交条件`);
+    }
+    const review = await reviewPreparedDraft(page, entry, options);
+    if (review) {
+      return { ...review, ...richContent };
+    }
+    if (options.draftOnly) {
+      return {
+        url: page.url(),
+        status: "draft",
+        draftOnly: true,
+        approvalRequired: true,
+        approvalActions: ["publish", "cancel"],
+        ...richContent
+      };
     }
-    await reviewPreparedDraft(page, entry, options);
     if (entry.platformKey === "haoyou") {
       const initialUrl = page.url();
       const mutationPromise =
@@ -6689,12 +7535,18 @@ export async function publishWithBrowser(entry, article, options = {}) {
     }
     return { url: page.url() };
   } catch (error) {
-    if (entry.platformKey === "haoyou" && ownsContext && haoyouEditorOpened) {
-      await promptUser(`${error.message}，浏览器将保持打开供检查`).catch(() => {});
+    if ((entry.platformKey === "haoyou" && haoyouEditorOpened) || entry.platformKey === "xiaohongshu") {
+      if (!ownsContext) throw error;
+      preserveEditorOnFailure = true;
+      options.onProgress?.(`${error.message}；已保留${entry.platform}编辑页供检查`);
     }
     throw error;
   } finally {
-    await context.close().catch(() => {});
+    // A draft is deliberately left visible for the current AI conversation.
+    // Closing the persistent context here also closes the platform's editor page.
+    if (ownsContext && !options.draftOnly && !options.keepOpen && !options.awaitAIAction && !preserveEditorOnFailure) {
+      await closeBrowserContext(context);
+    }
   }
 }
 
@@ -6703,7 +7555,13 @@ export async function publishPlatformEntry(entry, article, options = {}) {
     return publishDiscord(entry, article, options);
   }
   if (entry.publisher === "browser") {
-    return publishWithBrowser(entry, article, options);
+    const submissionKey = await ensureBrowserSubmissionCooldown(entry, article, options);
+    const result = await publishWithBrowser(entry, article, options);
+    if (result?.status === "published") {
+      await recordBrowserSubmission(submissionKey);
+      await removeDetachedBrowserSession(browserProfileDir(entry));
+    }
+    return result;
   }
   if (entry.publisher === "blocked") {
     throw new Error("Reddit 配置明确提示非官方工具可能导致封号；未配置 Reddit 官方应用，因此拒绝自动发布");
@@ -6714,6 +7572,46 @@ export async function publishPlatformEntry(entry, article, options = {}) {
   throw new Error(`${entry.platform} 需要由官网发布流程处理`);
 }
 
+/**
+ * Persist non-official platform addresses next to the article as a small,
+ * reviewable project artifact. Credentials and configuration URLs are never
+ * copied; only addresses returned by a completed platform workflow are kept.
+ */
+export async function writePlatformPublishUrls(articleFile, successes) {
+  const records = successes
+    .filter(({ entry }) => entry?.platformKey && entry.platformKey !== "website")
+    .map(({ entry, result }) => {
+      const url = normalizeText(
+        result?.status === "draft" ? result?.url : result?.publishedUrl || result?.responseUrl || result?.url
+      );
+      let isInternalApi = /\/webapi(?:v\d+)?\//i.test(url);
+      try {
+        const parsedUrl = new URL(url);
+        isInternalApi ||= parsedUrl.searchParams.get("m") === "api" || /\/api(?:\/|$)/i.test(parsedUrl.pathname);
+      } catch {
+        // Non-URL values are omitted by the subsequent truthy URL filter.
+      }
+      return {
+        platform: entry.platform,
+        platformKey: entry.platformKey,
+        region: entry.region,
+        status: result?.status || "completed",
+        // A draft must point back to the editor. Never persist a mutation API
+        // endpoint as though it were a public article address.
+        url: isInternalApi ? "" : url
+      };
+    })
+    .filter(record => record.url);
+  if (!records.length) return "";
+  const target = `${path.resolve(articleFile)}.platform-urls.json`;
+  await fs.promises.writeFile(
+    target,
+    `${JSON.stringify({ version: 1, updated_at: new Date().toISOString(), platforms: records }, null, 2)}\n`,
+    "utf8"
+  );
+  return target;
+}
+
 export async function runPlatformPublishSequence(entries, publishOne) {
   const successes = [];
   const failures = [];