@sovovs/bycli 2.1.23 → 2.1.25

package/clis/weixin/_wechat/sogou-fallback.js

@@ -0,0 +1,223 @@
+import {
+  ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError,
+} from '@sovovs/bycli/errors';
+import { resolveWechatArticleUrl } from './article-link.js';
+import { redactText } from './redact.js';
+import {
+  DEFAULT_SOGOU_MAX_PAGES,
+  normalizePositiveInteger,
+  searchSogouArticlePage,
+} from './sogou-search.js';
+
+const CST_OFFSET_MS = 8 * 60 * 60 * 1000;
+
+export function isExactAccountName(actual, expected) {
+  const normalizedActual = String(actual ?? '').trim().toLowerCase();
+  const normalizedExpected = String(expected ?? '').trim().toLowerCase();
+  return normalizedExpected.length > 0 && normalizedActual === normalizedExpected;
+}
+
+function normalizedUrl(raw) {
+  try {
+    return new URL(raw).href;
+  } catch {
+    return String(raw ?? '').trim();
+  }
+}
+
+function comparableTimestamp(raw) {
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value <= 0) return null;
+  return value >= 1_000_000_000_000 ? Math.floor(value / 1000) : value;
+}
+
+function validCstEpochSeconds(year, month, day, hour, minute, second) {
+  const epochMs = Date.UTC(year, month - 1, day, hour, minute, second) - CST_OFFSET_MS;
+  const check = new Date(epochMs + CST_OFFSET_MS);
+  if (check.getUTCFullYear() !== year || check.getUTCMonth() !== month - 1
+      || check.getUTCDate() !== day || check.getUTCHours() !== hour
+      || check.getUTCMinutes() !== minute || check.getUTCSeconds() !== second) return null;
+  return Math.floor(epochMs / 1000);
+}
+
+export function normalizeSogouPublishTimestamp({
+  publishTimestamp,
+  publishTime,
+  scanStartedAt,
+}) {
+  const raw = comparableTimestamp(publishTimestamp);
+  if (raw !== null) return Math.floor(raw);
+  const startMs = Number(scanStartedAt);
+  if (!Number.isFinite(startMs)) return null;
+  const text = String(publishTime ?? '').trim();
+
+  const relative = text.match(/^(\d+)(分钟|小时|天)前$/);
+  if (relative) {
+    const amount = Number(relative[1]);
+    const secondsPerUnit = { 分钟: 60, 小时: 3600, 天: 86400 }[relative[2]];
+    if (!Number.isSafeInteger(amount)) return null;
+    const timestamp = Math.floor(startMs / 1000) - amount * secondsPerUnit;
+    return Number.isSafeInteger(timestamp) && timestamp > 0 ? timestamp : null;
+  }
+
+  const dayWord = text.match(/^(昨天|前天)(?:\s+(\d{1,2}):(\d{2})(?::(\d{2}))?)?$/);
+  if (dayWord) {
+    const cstNow = new Date(startMs + CST_OFFSET_MS);
+    const dayOffset = dayWord[1] === '昨天' ? 1 : 2;
+    const clock = dayWord[2] === undefined
+      ? [cstNow.getUTCHours(), cstNow.getUTCMinutes(), cstNow.getUTCSeconds()]
+      : [Number(dayWord[2]), Number(dayWord[3]), Number(dayWord[4] ?? 0)];
+    const prior = new Date(Date.UTC(
+      cstNow.getUTCFullYear(), cstNow.getUTCMonth(), cstNow.getUTCDate() - dayOffset,
+    ));
+    return validCstEpochSeconds(
+      prior.getUTCFullYear(), prior.getUTCMonth() + 1, prior.getUTCDate(), ...clock,
+    );
+  }
+
+  const absolute = text.match(
+    /^(\d{4})(?:-(\d{1,2})-(\d{1,2})|\/(\d{1,2})\/(\d{1,2})|年(\d{1,2})月(\d{1,2})日)(?:\s+(\d{1,2}):(\d{2})(?::(\d{2}))?)?$/,
+  );
+  if (!absolute) return null;
+  const month = Number(absolute[2] ?? absolute[4] ?? absolute[6]);
+  const day = Number(absolute[3] ?? absolute[5] ?? absolute[7]);
+  return validCstEpochSeconds(
+    Number(absolute[1]), month, day,
+    Number(absolute[8] ?? 0), Number(absolute[9] ?? 0), Number(absolute[10] ?? 0),
+  );
+}
+
+function safeResolutionError(error) {
+  const message = error instanceof Error ? error.message : 'Sogou article link resolution failed';
+  return redactText(message, []) || 'Sogou article link resolution failed';
+}
+
+export async function collectSogouAccountArticles({
+  page,
+  accountName,
+  limit,
+  maxPages,
+  searchPage = searchSogouArticlePage,
+  resolveUrl = resolveWechatArticleUrl,
+  resolutionPolicy = 'atomic',
+  scanStartedAt = Date.now(),
+}) {
+  const normalizedName = String(accountName ?? '').trim();
+  if (!normalizedName) {
+    throw new ArgumentError(
+      'weixin Sogou fallback requires --name',
+      'Pass the exact official-account name with --name.',
+    );
+  }
+  if (!['atomic', 'rows'].includes(resolutionPolicy)) {
+    throw new ArgumentError('Invalid Sogou fallback resolution policy');
+  }
+  const pageLimit = normalizePositiveInteger(
+    maxPages,
+    'max-pages',
+    DEFAULT_SOGOU_MAX_PAGES,
+  );
+  const articleLimit = limit === undefined || limit === null
+    ? null : normalizePositiveInteger(limit, 'limit');
+  const seenFingerprints = new Set();
+  const seenSogouUrls = new Set();
+  const candidates = [];
+  let pagesScanned = 0;
+  let coverage = 'max-pages-reached';
+  let firstSeen = 0;
+
+  for (let pageNo = 1; pageNo <= pageLimit; pageNo += 1) {
+    const result = await searchPage(page, { query: normalizedName, pageNo });
+    pagesScanned += 1;
+    if (result.state === 'empty') {
+      coverage = 'search-exhausted';
+      break;
+    }
+    if (seenFingerprints.has(result.fingerprint)) {
+      throw new CommandExecutionError(
+        'Sogou Weixin repeated a result page while scanning account articles',
+        `Page ${pageNo} repeated an earlier page; refusing to return a partial article index.`,
+      );
+    }
+    seenFingerprints.add(result.fingerprint);
+    for (const item of result.rows) {
+      if (!isExactAccountName(item.account, normalizedName)) continue;
+      const sourceKey = normalizedUrl(item.url);
+      if (seenSogouUrls.has(sourceKey)) continue;
+      seenSogouUrls.add(sourceKey);
+      candidates.push({
+        ...item,
+        firstSeen,
+        sourceKey,
+        normalizedTimestamp: normalizeSogouPublishTimestamp({
+          publishTimestamp: item.publishTimestamp,
+          publishTime: item.publishTime,
+          scanStartedAt,
+        }),
+      });
+      firstSeen += 1;
+    }
+  }
+
+  if (candidates.length === 0) {
+    const coverageHint = coverage === 'max-pages-reached'
+      ? `Scanned ${pagesScanned} pages and reached the page cap; later pages may still contain a match.`
+      : `Sogou search exhausted after ${pagesScanned} pages.`;
+    throw new EmptyResultError(
+      'weixin Sogou account fallback',
+      `No Sogou articles matched the exact official-account name "${normalizedName}"; similarly named accounts were excluded. ${coverageHint}`,
+    );
+  }
+
+  candidates.sort((left, right) => {
+    const leftTime = left.normalizedTimestamp;
+    const rightTime = right.normalizedTimestamp;
+    if (leftTime !== null && rightTime !== null && leftTime !== rightTime) return rightTime - leftTime;
+    if (leftTime !== null && rightTime === null) return -1;
+    if (leftTime === null && rightTime !== null) return 1;
+    return left.firstSeen - right.firstSeen;
+  });
+
+  const seenResolvedUrls = new Set();
+  const articles = [];
+  const resolutionFailures = [];
+  let terminalCount = 0;
+  for (const candidate of candidates) {
+    if (articleLimit !== null && terminalCount >= articleLimit) break;
+    try {
+      const resolved = await resolveUrl(page, candidate.url);
+      const resolvedKey = normalizedUrl(resolved.resolvedUrl);
+      if (seenResolvedUrls.has(resolvedKey)) continue;
+      seenResolvedUrls.add(resolvedKey);
+      articles.push({
+        title: candidate.title,
+        author: null,
+        digest: candidate.summary || null,
+        publishedAt: candidate.publishTime || null,
+        url: resolved.resolvedUrl,
+        sourceUrl: resolved.sourceUrl,
+        order: terminalCount,
+      });
+      terminalCount += 1;
+    } catch (error) {
+      if (error instanceof AuthRequiredError || resolutionPolicy === 'atomic') throw error;
+      resolutionFailures.push({
+        title: candidate.title,
+        status: 'failed',
+        stage: 'resolve',
+        error: safeResolutionError(error),
+        url: candidate.url,
+        order: terminalCount,
+      });
+      terminalCount += 1;
+    }
+  }
+
+  return {
+    source: 'sogou',
+    coverage,
+    pagesScanned,
+    articles,
+    resolutionFailures,
+  };
+}

package/clis/weixin/_wechat/sogou-search.js

@@ -0,0 +1,143 @@
+import {
+  ArgumentError, AuthRequiredError, CommandExecutionError,
+} from '@sovovs/bycli/errors';
+
+const SOGOU_WEIXIN_DOMAIN = 'weixin.sogou.com';
+export const DEFAULT_SOGOU_MAX_PAGES = 50;
+
+export function normalizePositiveInteger(value, name, defaultValue, maxValue) {
+  if (value === undefined || value === null) return defaultValue;
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text)) {
+    throw new ArgumentError(
+      `weixin sougousearch --${name} must be a positive integer`,
+      `Pass --${name} as a whole number${maxValue ? ` from 1 to ${maxValue}` : ' greater than 0'}.`,
+    );
+  }
+  const parsed = Number(text);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || (maxValue && parsed > maxValue)) {
+    throw new ArgumentError(
+      `weixin sougousearch --${name} is out of range`,
+      `Pass --${name} as a whole number${maxValue ? ` from 1 to ${maxValue}` : ' greater than 0'}.`,
+    );
+  }
+  return parsed;
+}
+
+export function buildSogouSearchUrl(query, pageNo) {
+  const searchUrl = new URL('https://weixin.sogou.com/weixin');
+  searchUrl.searchParams.set('query', query);
+  searchUrl.searchParams.set('type', '2');
+  searchUrl.searchParams.set('page', String(pageNo));
+  searchUrl.searchParams.set('ie', 'utf8');
+  return searchUrl.toString();
+}
+
+export function buildExtractSogouSearchResultsEvaluate() {
+  return String.raw`(() => {
+    const clean = (value) => {
+      return (value || '')
+        .replace(/\s+/g, ' ')
+        .replace(/<!--red_beg-->|<!--red_end-->/g, '')
+        .replace(/document\.write\(timeConvert\(['"]\d+['"]\)\)/g, '')
+        .trim();
+    };
+
+    const absolutize = (href) => {
+      if (!href) return '';
+      try {
+        return new URL(href, window.location.origin).toString();
+      } catch {
+        return href;
+      }
+    };
+
+    const bodyText = clean(document.body && document.body.innerText);
+    const blocked = /验证码|安全验证|异常访问|访问过于频繁|请输入验证码/.test(bodyText);
+    const empty = /没有找到相关的微信文章|未找到相关|暂无相关|没有找到/.test(bodyText)
+      || Boolean(document.querySelector('.no-result, .no_result, .s-noresult'));
+    const cards = Array.from(document.querySelectorAll('.news-list li'));
+    const extracted = cards.map((item) => {
+      const linkEl = item.querySelector('h3 a[href]');
+      const summaryEl = item.querySelector('p.txt-info');
+      const accountEl = item.querySelector('.s-p .all-time-y2');
+      const timeEl = item.querySelector('.s-p .s2');
+      const rawTimeHtml = timeEl && timeEl.innerHTML || '';
+      const timestampMatch = rawTimeHtml.match(/timeConvert\(['"](\d{10,13})['"]\)/);
+      return {
+        title: clean(linkEl && linkEl.textContent),
+        account: clean(accountEl && accountEl.textContent),
+        url: absolutize(linkEl && linkEl.getAttribute('href')),
+        summary: clean(summaryEl && summaryEl.textContent),
+        publishTime: clean(timeEl && timeEl.textContent),
+        publishTimestamp: timestampMatch ? Number(timestampMatch[1]) : null,
+      };
+    });
+    const rows = extracted.filter((row) => row.title && row.url);
+
+    return {
+      blocked,
+      empty,
+      invalidCount: extracted.length - rows.length,
+      rows,
+    };
+  })()`;
+}
+
+function fingerprintRows(rows) {
+  return rows.map(row => `${row.title}\u0000${row.url}`).join('\u0001');
+}
+
+export async function searchSogouArticlePage(page, { query, pageNo }) {
+  const normalizedQuery = String(query ?? '').trim();
+  if (!normalizedQuery) {
+    throw new ArgumentError(
+      'A search query is required.',
+      'Pass a non-empty keyword to search Weixin articles via Sogou.',
+    );
+  }
+  const normalizedPage = normalizePositiveInteger(pageNo, 'page', 1);
+  const searchUrl = buildSogouSearchUrl(normalizedQuery, normalizedPage);
+  let payload;
+  try {
+    await page.goto(searchUrl);
+    await page.wait(2);
+    payload = await page.evaluate(buildExtractSogouSearchResultsEvaluate());
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CommandExecutionError('weixin sougousearch failed while loading Sogou results', detail);
+  }
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.rows)) {
+    throw new CommandExecutionError(
+      'weixin sougousearch returned an unreadable browser payload',
+      'Sogou Weixin may have changed its result page structure.',
+    );
+  }
+  if (payload.blocked) {
+    throw new AuthRequiredError(
+      SOGOU_WEIXIN_DOMAIN,
+      'Sogou Weixin requires verification. Complete it in the open browser tab and run the command again.',
+    );
+  }
+  if (payload.invalidCount > 0) {
+    throw new CommandExecutionError(
+      'Sogou Weixin returned article cards without required title or URL',
+      'The result page structure may have changed; refusing to return a partial result set.',
+    );
+  }
+  if (payload.rows.length === 0 && payload.empty) {
+    return { state: 'empty', page: normalizedPage, fingerprint: '', rows: [] };
+  }
+  if (payload.rows.length === 0) {
+    throw new CommandExecutionError(
+      'weixin sougousearch did not expose article result cards',
+      'Sogou Weixin may have changed its selectors or returned a transient shell page.',
+    );
+  }
+  return {
+    state: 'results',
+    page: normalizedPage,
+    fingerprint: fingerprintRows(payload.rows),
+    rows: payload.rows,
+  };
+}

package/clis/weixin/articles.js

@@ -1,8 +1,15 @@
 import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
 import { cli, Strategy } from '@sovovs/bycli/registry';
 import { readEnvironmentCredentials, resolveBrowserCredentials } from './_wechat/auth-session.js';
-import { callCrawler, collectArticles, createWechatApi } from './_wechat/crawler-runtime.js';
+import {
+  combineArticleFallbackErrors,
+  isEligibleArticleFallbackError,
+  withMissingFallbackName,
+} from './_wechat/article-fallback-policy.js';
+import { createArticleIndexFetcher } from './_wechat/article-index.js';
+import { callCrawler, collectArticles } from './_wechat/crawler-runtime.js';
 import { readAuthSource } from './_wechat/args.js';
+import { collectSogouAccountArticles } from './_wechat/sogou-fallback.js';
 
 const DOMAIN = 'mp.weixin.qq.com';
 const browserRequired = args => readAuthSource(args) === 'browser';
@@ -13,24 +20,48 @@ export const articlesCommand = cli({
   strategy: Strategy.COOKIE, browser: browserRequired,
   args: [
     { name: 'fakeid', positional: true, required: true, help: 'Official-account fakeid returned by weixin accounts' },
-    { name: 'name', help: 'Optional official-account name for display context' }, { name: 'limit', type: 'int', help: 'Maximum number of articles to return' }, { name: 'max-pages', type: 'int', help: 'Maximum number of history pages to scan' },
+    { name: 'name', help: 'Official-account name; exact case-insensitive match required for browser Sogou fallback' }, { name: 'limit', type: 'int', help: 'Maximum number of articles to return' }, { name: 'max-pages', type: 'int', help: 'Maximum number of history pages to scan' },
     { name: 'auth-source', default: 'browser', choices: ['browser', 'env'], help: 'Credential source: browser session or environment variables' },
   ],
-  columns: ['title', 'author', 'digest', 'publishedAt', 'url'],
+  columns: ['title', 'author', 'digest', 'publishedAt', 'url', 'source', 'coverage'],
   func: async (page, args) => {
     const fakeid = String(args.fakeid ?? '').trim();
     if (!fakeid) throw new ArgumentError('fakeid is required');
     const authSource = readAuthSource(args);
     const credentials = authSource === 'env'
       ? readEnvironmentCredentials(false) : await resolveBrowserCredentials(page);
-    const { articles } = await callCrawler(async () => {
-      const { fetchPage } = createWechatApi(credentials);
-      return collectArticles({ fakeid, fetchPage, limit: args.limit, maxPages: args['max-pages'] });
-    });
-    if (articles.length === 0) throw new EmptyResultError('weixin articles', `No published articles were found for ${fakeid}.`);
+    const fetchPage = createArticleIndexFetcher({ page, source: authSource, credentials });
+    let articles;
+    let source = 'wechat';
+    let coverage = null;
+    try {
+      const result = await callCrawler(() => collectArticles({
+        fakeid, fetchPage, limit: args.limit, maxPages: args['max-pages'],
+      }));
+      articles = result.articles;
+      if (articles.length === 0) {
+        throw new EmptyResultError('weixin articles', `No published articles were found for ${fakeid}.`);
+      }
+    } catch (primaryError) {
+      if (authSource !== 'browser' || !isEligibleArticleFallbackError(primaryError)) throw primaryError;
+      const accountName = String(args.name ?? '').trim();
+      if (!accountName) throw withMissingFallbackName('weixin articles', primaryError);
+      try {
+        const fallback = await collectSogouAccountArticles({
+          page, accountName, limit: args.limit, maxPages: args['max-pages'],
+        });
+        articles = fallback.articles;
+        source = fallback.source;
+        coverage = fallback.coverage;
+      } catch (fallbackError) {
+        throw combineArticleFallbackErrors({
+          operation: 'weixin articles', primaryError, fallbackError, credentials,
+        });
+      }
+    }
     return articles.map(article => ({
       title: article.title, author: article.author || null, digest: article.digest || null,
-      publishedAt: article.publishedAt || null, url: article.url,
+      publishedAt: article.publishedAt || null, url: article.url, source, coverage,
     }));
   },
 });

package/clis/weixin/create-draft.js

@@ -1,8 +1,61 @@
+import * as nodeFs from 'node:fs';
+import * as nodePath from 'node:path';
 import { cli, Strategy } from '@sovovs/bycli/registry';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
 
 const WEIXIN_DOMAIN = 'mp.weixin.qq.com';
 const WEIXIN_HOME = 'https://mp.weixin.qq.com/';
+const MAX_TITLE_LENGTH = 64;
+const MAX_AUTHOR_LENGTH = 8;
+const SUPPORTED_COVER_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+
+function codePointLength(value) {
+    return [...value].length;
+}
+
+function requiredText(value, name) {
+    const text = String(value ?? '').trim();
+    if (!text) throw new ArgumentError(`${name} must not be empty`);
+    return text;
+}
+
+function validateCoverImage(value) {
+    if (value === undefined || value === null) return null;
+    const coverPath = nodePath.resolve(requiredText(value, 'cover-image'));
+    const extension = nodePath.extname(coverPath).toLowerCase();
+    if (!SUPPORTED_COVER_EXTENSIONS.has(extension)) {
+        throw new ArgumentError('cover-image must be a jpg, jpeg, png, gif, or webp file');
+    }
+    const info = nodeFs.statSync(coverPath, { throwIfNoEntry: false });
+    if (!info?.isFile() || info.size <= 0) {
+        throw new ArgumentError(`cover-image must be a readable non-empty file: ${coverPath}`);
+    }
+    try {
+        nodeFs.accessSync(coverPath, nodeFs.constants.R_OK);
+    } catch {
+        throw new ArgumentError(`cover-image must be readable: ${coverPath}`);
+    }
+    return coverPath;
+}
+
+function normalizeCreateDraftArgs(kwargs) {
+    const title = requiredText(kwargs.title, 'title');
+    requiredText(kwargs.content, 'content');
+    if (codePointLength(title) > MAX_TITLE_LENGTH) {
+        throw new ArgumentError(`title must be at most ${MAX_TITLE_LENGTH} characters`);
+    }
+    const author = kwargs.author == null ? null : requiredText(kwargs.author, 'author');
+    if (author && codePointLength(author) > MAX_AUTHOR_LENGTH) {
+        throw new ArgumentError(`author must be at most ${MAX_AUTHOR_LENGTH} characters`);
+    }
+    return {
+        title,
+        content: String(kwargs.content),
+        author,
+        summary: kwargs.summary == null ? null : String(kwargs.summary).trim(),
+        coverImage: validateCoverImage(kwargs['cover-image']),
+    };
+}
 
 async function getToken(page) {
     return page.evaluate(`(window.location.href.match(/token=(\\d+)/)||[])[1]`);
@@ -27,15 +80,18 @@ async function fillField(page, selector, value) {
     return page.evaluate(`(() => {
         var el = document.querySelector('${selector}');
         if (!el) return { ok: false, reason: 'not found: ${selector}' };
+        var expected = ${JSON.stringify(value)};
         el.focus();
         var proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
         var setter = Object.getOwnPropertyDescriptor(proto, 'value');
-        if (setter && setter.set) setter.set.call(el, ${JSON.stringify(value)});
-        else el.value = ${JSON.stringify(value)};
-        el.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(value)} }));
+        if (setter && setter.set) setter.set.call(el, expected);
+        else el.value = expected;
+        el.dispatchEvent(new InputEvent('input', { bubbles: true, data: expected }));
         el.dispatchEvent(new Event('change', { bubbles: true }));
         el.blur();
-        return { ok: true };
+        return el.value === expected
+            ? { ok: true, value: el.value }
+            : { ok: false, reason: 'value mismatch', value: el.value };
     })()`);
 }
 
@@ -49,10 +105,21 @@ async function fillContent(page, text) {
         document.execCommand('selectAll', false, null);
         document.execCommand('insertText', false, ${JSON.stringify(text)});
         editor.dispatchEvent(new InputEvent('input', { bubbles: true }));
-        return { ok: true };
+        var normalize = value => String(value ?? '').replace(/\\r\\n?/g, '\\n').trim();
+        var expected = normalize(${JSON.stringify(text)});
+        var actual = normalize(editor.innerText ?? editor.textContent ?? '');
+        return actual === expected
+            ? { ok: true, value: actual }
+            : { ok: false, reason: 'value mismatch', value: actual };
     })()`);
 }
 
+function requirePageResult(result, label) {
+    if (!result?.ok) {
+        throw new CommandExecutionError(`Failed to fill ${label}: ${result?.reason ?? 'unverified page state'}`);
+    }
+}
+
 async function uploadContentImage(page, imagePath) {
     const fs = await import('node:fs');
     const path = await import('node:path');
@@ -76,15 +143,20 @@ async function uploadContentImage(page, imagePath) {
     await page.wait(1);
 
     await page.setFileInput([absPath], 'input[type="file"][name="file"]');
-    await page.wait(8);
 
-    const cdnCount = await page.evaluate(`(() => {
-        var editor = document.querySelector('#ueditor_0');
-        return editor ? editor.querySelectorAll('img[src*="mmbiz"]').length : 0;
-    })()`);
-    if (cdnCount === 0) {
-        throw new CommandExecutionError('Image did not upload to WeChat CDN');
+    for (let attempt = 0; attempt < 15; attempt++) {
+        await page.wait(1);
+        const cdnCount = await page.evaluate(`(() => {
+            var editors = document.querySelectorAll('#ueditor_0, div[contenteditable="true"]');
+            var count = 0;
+            editors.forEach(function(editor) {
+                count += editor.querySelectorAll('img[src*="mmbiz"], img[data-src*="mmbiz"]').length;
+            });
+            return count;
+        })()`);
+        if (cdnCount > 0) return;
     }
+    throw new CommandExecutionError('Image did not upload to WeChat CDN');
 }
 
 async function selectCoverFromContent(page) {
@@ -134,18 +206,23 @@ async function selectCoverFromContent(page) {
             if (btns[i].textContent.trim() === '确认' && btns[i].offsetHeight > 0 && !btns[i].disabled) { btns[i].click(); return; }
         }
     })()`);
-    await page.wait(2);
-    const hasCover = await page.evaluate(`(() => {
-        var area = document.querySelector('#js_cover_area');
-        if (!area) return false;
-        var found = false;
-        area.querySelectorAll('*').forEach(function(el) {
-            var bg = window.getComputedStyle(el).backgroundImage;
-            if (bg && bg.includes('mmbiz')) found = true;
-        });
-        return found;
-    })()`);
-    return hasCover;
+    for (let attempt = 0; attempt < 15; attempt++) {
+        await page.wait(1);
+        const hasCover = await page.evaluate(`(() => {
+            var areas = document.querySelectorAll('#js_cover_area, #js_cover_description_area, #appmsgItem');
+            var found = false;
+            areas.forEach(function(area) {
+                if (area.querySelector('img[src*="mmbiz"], img[data-src*="mmbiz"]')) found = true;
+                [area].concat(Array.from(area.querySelectorAll('*'))).forEach(function(el) {
+                    var bg = window.getComputedStyle(el).backgroundImage;
+                    if (bg && bg.includes('mmbiz')) found = true;
+                });
+            });
+            return found;
+        })()`);
+        if (hasCover) return true;
+    }
+    return false;
 }
 
 async function clickSaveDraft(page) {
@@ -167,7 +244,7 @@ async function clickSaveDraft(page) {
         })()`);
         if (saved) return true;
     }
-    return false;
+    throw new CommandExecutionError('Draft save could not be confirmed');
 }
 
 export const createDraftCommand = cli({
@@ -190,37 +267,39 @@ export const createDraftCommand = cli({
     columns: ['status', 'detail'],
 
     func: async (page, kwargs) => {
+        const args = normalizeCreateDraftArgs(kwargs);
         await navigateToEditor(page);
 
-        const titleResult = await fillField(page, 'textarea#title', kwargs.title);
-        if (!titleResult?.ok) throw new CommandExecutionError('Failed to fill title');
+        const titleResult = await fillField(page, 'textarea#title', args.title);
+        requirePageResult(titleResult, 'title');
 
-        if (kwargs.author) {
-            const authorResult = await fillField(page, 'input#author', kwargs.author);
-            if (!authorResult?.ok) throw new CommandExecutionError('Failed to fill author');
+        if (args.author) {
+            const authorResult = await fillField(page, 'input#author', args.author);
+            requirePageResult(authorResult, 'author');
         }
 
-        const contentResult = await fillContent(page, kwargs.content);
-        if (!contentResult?.ok) throw new CommandExecutionError('Failed to fill content');
+        const contentResult = await fillContent(page, args.content);
+        requirePageResult(contentResult, 'content');
 
-        if (kwargs['cover-image']) {
-            await uploadContentImage(page, kwargs['cover-image']);
+        if (args.coverImage) {
+            await uploadContentImage(page, args.coverImage);
             const coverSet = await selectCoverFromContent(page);
             if (!coverSet) {
-                // Non-fatal: draft can be saved without cover
+                throw new CommandExecutionError('Failed to set the requested cover image');
             }
         }
 
-        if (kwargs.summary) {
-            await fillField(page, 'textarea#js_description', kwargs.summary);
+        if (args.summary) {
+            const summaryResult = await fillField(page, 'textarea#js_description', args.summary);
+            requirePageResult(summaryResult, 'summary');
         }
 
         await page.wait(1);
-        const success = await clickSaveDraft(page);
+        await clickSaveDraft(page);
 
         return [{
-            status: success ? 'draft saved' : 'save attempted, check browser to confirm',
-            detail: `"${kwargs.title}"${kwargs.author ? ` by ${kwargs.author}` : ''}${kwargs['cover-image'] ? ' (with cover)' : ''}`,
+            status: 'draft saved',
+            detail: `"${args.title}"${args.author ? ` by ${args.author}` : ''}${args.coverImage ? ' (with cover)' : ''}`,
         }];
     },
 });