@gobing-ai/knowledge-kit 0.0.27 → 0.0.28

package/plugins/publishings/wechatmp-pub/src/index.ts

@@ -6,10 +6,10 @@ import {
     type PublishTransportPayload,
     resolveBrowserProfileDir,
 } from '@gobing-ai/publish-harness';
-import { BrowserProfileMissingError, withProfilePage } from '@gobing-ai/ts-browser-automation';
+import { BrowserProfileMissingError, openPersistentBrowser } from '@gobing-ai/ts-browser-automation';
 import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { echoError } from '@gobing-ai/ts-utils';
-import type { Page } from 'playwright';
+import type { BrowserContext, Cookie, Page } from 'playwright';
 
 const TARGET = 'wechatmp';
 const CONSOLE_URL = 'https://mp.weixin.qq.com/';
@@ -19,11 +19,19 @@ const SEL = {
     // Console home: an authenticated session lands on /cgi-bin/home; logged-out shows the QR scan page.
     loggedInFragment: '/cgi-bin/home',
     menuItem: '.new-creation__menu .new-creation__menu-item',
-    titleInput: '#title',
+    // The 2024+ console editor renders title/body as two ProseMirror instances; the legacy
+    // textarea#title is a hidden mirror. The title PM carries a 标题 placeholder — the only
+    // reliable discriminator between the two editors.
+    titleInput: '.ProseMirror[data-placeholder*="标题"]',
     authorInput: '#author',
-    editor: '.ProseMirror',
+    editor: '.ProseMirror:not([data-placeholder])',
     summaryInput: '#js_description',
-    saveDraftBtn: '.js_save_draft, button:has-text("保存为草稿"), button:has-text("保存草稿")',
+    saveDraftBtn: 'button:has-text("保存为草稿")',
+    originalSwitch: '.setting-group__switch.js_edit_ori',
+    tagRow: '.allow_click_opr.js_article_tags_label',
+    tagInput: 'input[placeholder*="合集"]',
+    claimSourceCheckbox: '#js_claim_source_area .frm_checkbox_label',
+    coverBtn: '.js_cover_btn_area',
     publishBtn: '.js_publish, button:has-text("发表"), button:has-text("发布")',
     confirmBtn: '.weui-desktop-dialog .weui-desktop-btn_primary, button:has-text("确定")',
     toast: '.weui-desktop-toast',
@@ -145,10 +153,21 @@ export interface WechatPage {
     goto(url: string): Promise<void>;
     url(): string;
     fill(selector: string, value: string): Promise<void>;
-    click(selector: string): Promise<void>;
+    click(selector: string, timeoutMs?: number): Promise<void>;
+    press?(key: string): Promise<void>;
     setInnerHtml(selector: string, html: string): Promise<void>;
     waitFor(selector: string, timeoutMs: number): Promise<void>;
     waitForAny(selectors: readonly string[], timeoutMs: number): Promise<string>;
+    /** Resolves when the page URL contains the fragment (real browsers); absent on test fakes. */
+    waitForUrlFragment?(fragment: string, timeoutMs: number): Promise<void>;
+    setInputFiles?(selector: string, files: string): Promise<void>;
+    waitForTimeout?(ms: number): Promise<void>;
+    /** Evaluate a JS expression in the page (real browsers) - used for commit verification; absent on fakes. */
+    evalJs?(expression: string): Promise<unknown>;
+    /** Click and adopt the tab the console opens for the editor; absent on test fakes (same-page click). */
+    clickAndAwaitNewPage?(selector: string): Promise<WechatPage>;
+    /** Present on real browser pages; absent on test fakes. publish() closes it in finally. */
+    close?(): Promise<void>;
 }
 
 export function isWechatLoggedIn(page: Page): boolean {
@@ -157,18 +176,33 @@ export function isWechatLoggedIn(page: Page): boolean {
 
 export type SessionCheck = (profileDir: string) => Promise<void>;
 
+/** Cookies captured at login time — mp.weixin.qq.com grant cookies do not survive a Chromium restart
+ * (the store drops them despite 4-day expiries), but the server session does, so we re-inject. */
+export function storageStatePath(profileDir: string): string {
+    return `${profileDir}/storage-state.json`;
+}
+
 /** Headless session preflight: throws (incl. BrowserProfileMissingError) when the profile cannot drive the console. */
 export async function checkWechatSession(profileDir: string): Promise<void> {
-    await withProfilePage(
-        {
-            profileDir,
-            headless: true,
-            url: CONSOLE_URL,
-            isAuthenticated: isWechatLoggedIn,
-            timeoutMs: CONSOLE_READY_TIMEOUT_MS,
-        },
-        async () => {},
-    );
+    const { page, context } = await openWithState(profileDir, true);
+    try {
+        await pollLogin(page);
+    } finally {
+        await context.close();
+    }
+}
+
+async function pollLogin(page: Page): Promise<void> {
+    const deadline = Date.now() + CONSOLE_READY_TIMEOUT_MS;
+    while (!isWechatLoggedIn(page)) {
+        if (Date.now() > deadline) {
+            throw new Error(
+                `Authentication was not confirmed within ${CONSOLE_READY_TIMEOUT_MS}ms — the saved session state has ` +
+                    'likely expired: re-run `bun src/profile-check.ts login` to sign in again.',
+            );
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
 }
 
 export interface WechatmpTransportOptions {
@@ -176,12 +210,16 @@ export interface WechatmpTransportOptions {
     checkSession?: SessionCheck;
 }
 
-export function wrapPlaywrightPage(page: Page): WechatPage {
+export function wrapPlaywrightPage(page: Page, context?: BrowserContext): WechatPage {
     return {
         goto: (url) => page.goto(url, { waitUntil: 'domcontentloaded' }).then(() => undefined),
         url: () => page.url(),
         fill: (selector, value) => page.locator(selector).first().fill(value),
-        click: (selector) => page.locator(selector).first().click(),
+        click: (selector, timeoutMs) =>
+            page
+                .locator(selector)
+                .first()
+                .click(timeoutMs ? { timeout: timeoutMs } : undefined),
         setInnerHtml: (selector, html) =>
             page
                 .locator(selector)
@@ -210,13 +248,59 @@ export function wrapPlaywrightPage(page: Page): WechatPage {
             }
             return '';
         },
+        waitForUrlFragment: (fragment, timeoutMs) =>
+            page
+                .waitForURL(new RegExp(fragment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), { timeout: timeoutMs })
+                .then(() => undefined),
+        setInputFiles: (selector, files) => page.locator(selector).first().setInputFiles(files),
+        waitForTimeout: (ms) => page.waitForTimeout(ms),
+        evalJs: (expression) => page.evaluate(expression),
+        press: (key) => page.keyboard.press(key),
+        clickAndAwaitNewPage: context
+            ? async (selector) => {
+                  const popup = context.waitForEvent('page', { timeout: 15000 }).catch(() => undefined);
+                  await page.locator(selector).first().click();
+                  const opened = await popup;
+                  if (!opened) return wrapPlaywrightPage(page, context);
+                  await opened.waitForLoadState('domcontentloaded').catch(() => {});
+                  return wrapPlaywrightPage(opened, context);
+              }
+            : undefined,
+        close: context ? () => context.close() : undefined,
     };
 }
 
+/** Launch, inject the saved login cookies, and land on the console. Caller owns closing the context. */
+async function openWithState(profileDir: string, headless: boolean): Promise<{ page: Page; context: BrowserContext }> {
+    const context = await openPersistentBrowser({ profileDir, headless });
+    try {
+        const stateFile = storageStatePath(profileDir);
+        let state: { cookies?: Cookie[] } | undefined;
+        try {
+            state = JSON.parse(await createNodeFileSystem().readFile(stateFile));
+        } catch {
+            state = undefined; // absent or corrupt session state — reported below
+        }
+        const cookies = state?.cookies;
+        if (!cookies || cookies.length === 0) {
+            throw new BrowserProfileMissingError(
+                `no saved console session state (${stateFile}) — run \`bun src/profile-check.ts login\` once`,
+            );
+        }
+        await context.addCookies(cookies);
+        const page = context.pages()[0] ?? (await context.newPage());
+        await page.goto(CONSOLE_URL);
+        return { page, context };
+    } catch (error: unknown) {
+        await context.close();
+        throw error;
+    }
+}
+
 async function defaultOpenPage(profileDir: string): Promise<WechatPage> {
-    return withProfilePage({ profileDir, headless: false, url: CONSOLE_URL }, async (handle) =>
-        wrapPlaywrightPage(handle.page),
-    );
+    // Headless works end-to-end for the draft flow (probed 2026-09-29); no window is popped.
+    const { page, context } = await openWithState(profileDir, true);
+    return wrapPlaywrightPage(page, context);
 }
 
 export class WechatmpBrowserTransport implements PublishTransport {
@@ -257,29 +341,53 @@ export class WechatmpBrowserTransport implements PublishTransport {
         }
 
         const page = await this.openPage(profileDir);
+        let enrichWarnings: string[] = [];
         try {
             await page.waitFor(SEL.menuItem, CONSOLE_READY_TIMEOUT_MS);
-            await page.click(`${SEL.menuItem}:has-text("图文"), ${SEL.menuItem}`);
-            await page.waitFor(SEL.titleInput, CONSOLE_READY_TIMEOUT_MS);
-            await page.fill(SEL.titleInput, title);
-            await this.tryFill(page, SEL.authorInput, String(content.metadata?.author ?? ''));
-            await page.waitFor(SEL.editor, CONSOLE_READY_TIMEOUT_MS);
-            await page.setInnerHtml(SEL.editor, markdownToWechatHtml(content.body));
+            // The console opens the article editor in a new tab — adopt it when it appears.
+            const editor = page.clickAndAwaitNewPage
+                ? await page.clickAndAwaitNewPage(`${SEL.menuItem}:has-text("图文"), ${SEL.menuItem}`)
+                : page;
+            if (editor === page) {
+                await page.click(`${SEL.menuItem}:has-text("图文"), ${SEL.menuItem}`);
+            }
+            await editor.waitFor(SEL.titleInput, CONSOLE_READY_TIMEOUT_MS);
+            await editor.fill(SEL.titleInput, title);
+            await this.tryFill(editor, SEL.authorInput, String(content.metadata?.author ?? ''));
+            await editor.waitFor(SEL.editor, CONSOLE_READY_TIMEOUT_MS);
+            await editor.setInnerHtml(SEL.editor, markdownToWechatHtml(content.body));
             const digest = resolveDigest(content);
-            if (digest) await this.tryFill(page, SEL.summaryInput, digest);
+            if (digest) await this.tryFill(editor, SEL.summaryInput, digest);
+
+            const enrichMeta = content.metadata?.wechatmp;
+            if (enrichMeta && typeof enrichMeta === 'object' && !Array.isArray(enrichMeta)) {
+                enrichWarnings = await this.enrichDraft(editor, enrichMeta as Record<string, unknown>);
+                const audioTitle = (enrichMeta as Record<string, unknown>).audioTitle;
+                if (typeof audioTitle === 'string' && audioTitle.trim() !== '') {
+                    const audioWarn = await this.insertAudio(editor, audioTitle.trim());
+                    if (audioWarn !== '') enrichWarnings.push(audioWarn);
+                }
+            }
 
             if (want === 'draft') {
-                await page.click(SEL.saveDraftBtn);
+                await editor.click(SEL.saveDraftBtn);
             } else {
-                await page.click(SEL.publishBtn);
-                await this.tryClick(page, SEL.confirmBtn);
+                await editor.click(SEL.publishBtn);
+                await this.tryClick(editor, SEL.confirmBtn);
             }
-            const seen = await page.waitForAny([SEL.toast], TOAST_TIMEOUT_MS);
-            if (seen === '') {
-                return this.failed(
-                    `save was clicked but no confirmation toast appeared within ${TOAST_TIMEOUT_MS}ms — verify the console manually`,
-                );
+            // Real consoles confirm the draft save by navigating from the isNew editor
+            // (appmsg_edit_v2) to the saved-draft edit page carrying the new appmsgid.
+            if (editor.waitForUrlFragment) {
+                await editor.waitForUrlFragment('appmsg_edit&action=edit', CONSOLE_READY_TIMEOUT_MS);
+            } else {
+                const seen = await editor.waitForAny([SEL.toast], TOAST_TIMEOUT_MS);
+                if (seen === '') {
+                    return this.failed(
+                        `save was clicked but no confirmation toast appeared within ${TOAST_TIMEOUT_MS}ms — verify the console manually`,
+                    );
+                }
             }
+            const appmsgid = /appmsgid=(\d+)/.exec(editor.url())?.[1] ?? '';
             return {
                 ok: true,
                 target: TARGET,
@@ -287,13 +395,201 @@ export class WechatmpBrowserTransport implements PublishTransport {
                     publishStatus: want,
                     note:
                         want === 'draft'
-                            ? 'saved to the WeChat MP draft box (草稿箱)'
+                            ? `saved to the WeChat MP draft box (草稿箱)${appmsgid ? ` as appmsgid ${appmsgid}` : ''}`
                             : 'published via the console 发表 flow',
+                    ...(enrichWarnings.length > 0 ? { enrichWarnings } : {}),
                 },
             };
         } catch (error: unknown) {
             const why = error instanceof Error ? error.message : String(error);
-            return this.failed(`console flow failed: ${why}`);
+            const enrich = enrichWarnings.length > 0 ? ` (enrich warnings: ${enrichWarnings.join(' | ')})` : '';
+            return this.failed(`console flow failed: ${why}${enrich}`);
+        } finally {
+            await page.close?.();
+        }
+    }
+
+    /**
+     * Set the operator's draft metadata (原创/作者/合集/创作来源/封面) in the v2 editor.
+     * Runs on a FRESH draft only - the toggles are not state-aware (no idempotency for re-runs).
+     * Per-field failures are collected into warnings and surfaced in the Result; the draft still saves.
+     * Dialog mapping evidence (probes 2026-09-29, drafts 100000805/808): 原创 + 赞赏 share ONE dialog
+     * (声明类型 radios, 作者 input, 确定) - the 赞赏 switch stays hidden for this account, so 赞赏 is a manual step;
+     * 合集 dialog = 请选择合集 input + 确认; 创作来源 is an inline checkbox (no dialog); the 原文链接 row has
+     * no reachable URL input in headless - also manual; cover accepts a direct input[type=file] set.
+     * Commit verification (evalJs): the original dialog only closes when WeChat's validation passes - the
+     * author is the reward (shang) account and must be picked from its search, which does not resolve for
+     * this account headless; a non-closing dialog is swept and surfaced as a warning. Same for the
+     * creation-source checkbox (DOM re-check).
+     */
+    private async enrichDraft(editor: WechatPage, meta: Record<string, unknown>): Promise<string[]> {
+        const DIALOG = '.weui-desktop-dialog:visible';
+        const CONFIRM = `${DIALOG} button:has-text("确认"), ${DIALOG} button:has-text("确定")`;
+        const warnings: string[] = [];
+        const str = (key: string) => (typeof meta[key] === 'string' ? (meta[key] as string) : '');
+        const on = (key: string) => meta[key] === true;
+        // Sweep any leaked dialog so the next step (especially 保存为草稿) is never overlay-blocked.
+        const sweep = async () => {
+            await this.tryClick(editor, 'button:has-text("取消")', 2000);
+            await editor.press?.('Escape');
+            await editor.waitForTimeout?.(400);
+        };
+        // One retry per step: the settings panel re-renders after dialog confirms and can briefly
+        // detach rows (observed on the tags row right after the original-declaration confirm).
+        const step = async (name: string, fn: () => Promise<void>) => {
+            try {
+                await fn();
+                return;
+            } catch {
+                // retry once below
+            }
+            await sweep();
+            await editor.waitForTimeout?.(1000);
+            try {
+                await fn();
+            } catch (error) {
+                warnings.push(`${name}: ${(error instanceof Error ? error.message : String(error)).slice(0, 120)}`);
+                await sweep();
+            }
+        };
+        if (on('original')) {
+            await step('原创声明', async () => {
+                await editor.click(SEL.originalSwitch, 10000);
+                await editor.click(`${DIALOG} :text("文字原创")`, 8000);
+                const author = str('author');
+                if (author) await this.tryFill(editor, `${DIALOG} input[placeholder*="作者"]`, author);
+                await editor.click(CONFIRM, 8000);
+            });
+            const committed = await editor.evalJs?.(
+                `[...document.querySelectorAll('.weui-desktop-dialog')].every((d) => !d.offsetWidth)`,
+            );
+            if (committed === false) {
+                warnings.push('原创声明: 未生效 - 作者须为赞赏账户(搜索选择)，请手动设置');
+                await sweep();
+            }
+        }
+        const collection = str('collection');
+        if (collection) {
+            await step('合集', async () => {
+                await editor.click(SEL.tagRow, 8000);
+                await editor.waitFor(SEL.tagInput, 8000);
+                await editor.fill(SEL.tagInput, collection);
+                await editor.waitForTimeout?.(1200);
+                await editor.click(`${DIALOG} :text("${collection}")`, 8000);
+                await editor.click(CONFIRM, 8000);
+            });
+        }
+        if (on('aiGenerated')) {
+            await step('创作来源', async () => {
+                await editor.click(SEL.claimSourceCheckbox, 8000);
+                // Probes show no dialog on current builds — the checkbox alone declares AI generation.
+                const dialog = await editor.waitForAny([DIALOG], 3000);
+                if (dialog) {
+                    await editor.click(`${DIALOG} :text("内容由AI生成")`, 8000);
+                    await editor.click(CONFIRM, 8000);
+                }
+            });
+            const checked = await editor.evalJs?.(`!!document.querySelector('#js_claim_source_area input:checked')`);
+            if (checked === false) warnings.push('创作来源: 勾选未生效，请手动设置');
+        }
+        const coverPath = str('coverPath');
+        const putFile = editor.setInputFiles?.bind(editor);
+        if (coverPath && putFile) {
+            await step('封面', async () => {
+                try {
+                    await putFile('input[type="file"]', coverPath);
+                } catch {
+                    await editor.click(SEL.coverBtn, 8000);
+                    await editor.waitForTimeout?.(1500);
+                    await putFile('input[type="file"]', coverPath);
+                }
+                const cropBtn = await editor.waitForAny(
+                    [`${DIALOG} button:has-text("完成")`, `${DIALOG} button:has-text("确定")`],
+                    5000,
+                );
+                if (cropBtn) await editor.click(cropBtn, 8000);
+            });
+        }
+        await sweep();
+        return warnings;
+    }
+
+    /**
+     * Audio embed at the article top (operator request 2026-09-29): open the editor's audio menu
+     * (a hover dropdown - JS click bypasses the hover gate), reuse an existing same-title 素材库
+     * material, and insert at the caret (placed at the article start first). Upload of a missing
+     * material is deliberately manual for now: the 上传音频 form is iframe-based and unmapped.
+     * Fail-soft: every non-committed outcome returns a warning string; '' means placed at top.
+     */
+    private async insertAudio(editor: WechatPage, title: string): Promise<string> {
+        const evalJs = editor.evalJs;
+        if (typeof evalJs !== 'function') return '';
+        const CARET = `(() => {
+            const pm = [...document.querySelectorAll('.ProseMirror')].find((e) => !(e.getAttribute('data-placeholder') ?? '').includes('标题'));
+            if (!pm || !pm.firstChild) return;
+            const r = document.createRange();
+            r.setStart(pm.firstChild, 0);
+            r.collapse(true);
+            const sel = window.getSelection();
+            sel?.removeAllRanges();
+            sel?.addRange(r);
+        })()`;
+        const DEDUPE = `(() => {
+            const want = ${JSON.stringify(title)}.replace(/\\s+/g, '');
+            const hit = [...document.querySelectorAll('label.frm_checkbox_label.audio_item')]
+                .find((l) => (l.textContent ?? '').replace(/\\s+/g, '').includes(want));
+            if (!hit) return 'missing';
+            const cb = (hit.closest('li') ?? hit.parentElement)?.querySelector('input[type=checkbox]');
+            if (!cb) return 'nobox';
+            cb.click();
+            return 'checked';
+        })()`;
+        const INSERT = `(() => {
+            const btn = [...document.querySelectorAll('button')].find((b) => (b.textContent ?? '').trim() === '插入' && b.offsetWidth > 0);
+            if (!btn) return false;
+            btn.click();
+            return true;
+        })()`;
+        const CANCEL = `(() => {
+            const btn = [...document.querySelectorAll('button')].find((b) => (b.textContent ?? '').trim() === '取消' && b.offsetWidth > 0);
+            btn?.click();
+        })()`;
+        const VERIFY = `(() => {
+            const pm = [...document.querySelectorAll('.ProseMirror')].find((e) => !(e.getAttribute('data-placeholder') ?? '').includes('标题'));
+            if (!pm) return 'noeditor';
+            const node = pm.querySelector('mpvoice, [class*="audio"]');
+            if (!node) return 'absent';
+            const first = pm.firstElementChild;
+            return first && (first === node || first.contains(node)) ? 'top' : 'notop';
+        })()`;
+        try {
+            const run = (expression: string) => evalJs.call(editor, expression);
+            await run(CARET);
+            await run("document.querySelector('li.js_insertaudio')?.click()");
+            await editor.waitFor('.audio_dialog', TOAST_TIMEOUT_MS);
+            // The 素材库 list loads async after the dialog opens - retry while rows stream in.
+            let dedupe = String(await run(DEDUPE));
+            for (let i = 0; dedupe === 'missing' && i < 2; i++) {
+                await editor.waitForTimeout?.(1200);
+                dedupe = String(await run(DEDUPE));
+            }
+            if (dedupe !== 'checked') {
+                await run(CANCEL);
+                return dedupe === 'missing'
+                    ? '音频: 素材库无同名音频，请手动上传后插入'
+                    : '音频: 同名素材行未找到勾选框，请手动插入';
+            }
+            if ((await run(INSERT)) !== true) {
+                await run(CANCEL);
+                return '音频: 插入按钮未找到，请手动插入';
+            }
+            await editor.waitForTimeout?.(2000);
+            const state = String(await run(VERIFY));
+            if (state === 'absent' || state === 'noeditor') return '音频: 插入未生效，请手动检查';
+            if (state === 'notop') return '音频: 已插入但未在文首，请手动调整位置';
+            return '';
+        } catch {
+            return '音频: 自动插入失败，请手动插入';
         }
     }
 
@@ -306,9 +602,9 @@ export class WechatmpBrowserTransport implements PublishTransport {
         }
     }
 
-    private async tryClick(page: WechatPage, selector: string): Promise<void> {
+    private async tryClick(page: WechatPage, selector: string, timeoutMs?: number): Promise<void> {
         try {
-            await page.click(selector);
+            await page.click(selector, timeoutMs);
         } catch {
             // confirm dialogs are not shown for every account type
         }

package/plugins/publishings/wechatmp-pub/src/profile-check.ts

@@ -1,10 +1,11 @@
 import { resolveBrowserProfileDir } from '@gobing-ai/publish-harness';
-import { loginWithProfile } from '@gobing-ai/ts-browser-automation';
+import { openPersistentBrowser } from '@gobing-ai/ts-browser-automation';
 import { echo } from '@gobing-ai/ts-utils';
-import { checkWechatSession } from './index';
+import { checkWechatSession, storageStatePath } from './index';
 
 const CONSOLE_URL = 'https://mp.weixin.qq.com/';
 const LOGIN_TIMEOUT_MS = 180_000;
+const LOGGED_IN_FRAGMENT = '/cgi-bin/home';
 
 const profileDir = resolveBrowserProfileDir('wechatmp', process.env.WECHATMP_PROFILE_DIR);
 const verb = process.argv[2] ?? 'check';
@@ -14,13 +15,24 @@ try {
         echo(
             `wechatmp login: opening the console in a headed browser — scan the QR once (timeout ${LOGIN_TIMEOUT_MS / 1000}s)`,
         );
-        await loginWithProfile({
-            profileDir,
-            url: CONSOLE_URL,
-            isAuthenticated: (page) => page.url().includes('/cgi-bin/home'),
-            timeoutMs: LOGIN_TIMEOUT_MS,
-        });
-        echo(`wechatmp login: session saved in ${profileDir}`);
+        const context = await openPersistentBrowser({ profileDir, headless: false });
+        try {
+            const page = context.pages()[0] ?? (await context.newPage());
+            await page.goto(CONSOLE_URL);
+            const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+            while (!page.url().includes(LOGGED_IN_FRAGMENT)) {
+                if (Date.now() > deadline) throw new Error(`QR scan not completed within ${LOGIN_TIMEOUT_MS / 1000}s`);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            await page.waitForTimeout(10_000); // settle: let the console finish its post-auth Set-Cookies
+            // The Chromium profile store drops the grant cookies on restart even though they carry
+            // multi-day expiries — the durable session artifact is the captured storageState file,
+            // which the publish flow re-injects into every launch.
+            await context.storageState({ path: storageStatePath(profileDir) });
+            echo(`wechatmp login: session saved in ${storageStatePath(profileDir)}`);
+        } finally {
+            await context.close();
+        }
     } else if (verb === 'check') {
         await checkWechatSession(profileDir);
         echo(`wechatmp session: OK (${profileDir})`);

package/plugins/publishings/xhs-pub/dist/index.js

@@ -30411,29 +30411,35 @@ async function findAttachedSelector(page, selectors, what, timeoutMs = STEP_TIME
   throw new Error(`${what}: no matching element observed`);
 }
 async function checkXhsProfileSession(opts) {
-  try {
-    await withProfilePage({
-      profileDir: opts.profileDir,
-      headless: true,
-      url: PUBLISH_URL,
-      isAuthenticated: (page) => isXhsConsoleReady(wrapPlaywrightPage(page)),
-      timeoutMs: opts.timeoutMs ?? PREFLIGHT_TIMEOUT_MS,
-      launcher: opts.launcher
-    }, async () => {
-      return;
-    });
-    return {
-      status: "verified",
-      profileDir: opts.profileDir,
-      detail: `authenticated ${CHANNEL} creator console observed headlessly via profile ${opts.profileDir} (read-only)`
-    };
-  } catch (error51) {
-    return {
-      status: "refused",
-      profileDir: opts.profileDir,
-      detail: `headless readiness refused: ${error51 instanceof Error ? error51.message : String(error51)}`
-    };
+  const timeoutMs = opts.timeoutMs ?? PREFLIGHT_TIMEOUT_MS;
+  for (const headless of [true, false]) {
+    try {
+      await withProfilePage({
+        profileDir: opts.profileDir,
+        headless,
+        url: PUBLISH_URL,
+        isAuthenticated: (page) => isXhsConsoleReady(wrapPlaywrightPage(page)),
+        timeoutMs,
+        launcher: opts.launcher
+      }, async () => {
+        return;
+      });
+      return {
+        status: "verified",
+        profileDir: opts.profileDir,
+        detail: `authenticated ${CHANNEL} creator console observed ${headless ? "headlessly" : "via headed fallback"} via profile ${opts.profileDir} (read-only)`
+      };
+    } catch (error51) {
+      if (headless)
+        continue;
+      return {
+        status: "refused",
+        profileDir: opts.profileDir,
+        detail: `headless and headed readiness refused: ${error51 instanceof Error ? error51.message : String(error51)}`
+      };
+    }
   }
+  throw new Error("unreachable: session check loop must return or throw");
 }
 
 class XhsBrowserTransport {

package/plugins/publishings/xhs-pub/src/index.ts

@@ -427,30 +427,38 @@ export interface SessionCheckOptions {
  * `verified`, which is what turns "no session" from a 120s headed login wait into a fast refusal.
  */
 export async function checkXhsProfileSession(opts: SessionCheckOptions): Promise<ProfileSessionCheck> {
-    try {
-        await withProfilePage(
-            {
+    const timeoutMs = opts.timeoutMs ?? PREFLIGHT_TIMEOUT_MS;
+    // XHS bot-walls and slow-walls headless loads (observed 2026-09-29: headless auth never
+    // confirms while the same profile reads ready in 27s headed), so a headless refusal is
+    // retried once headed — still a read-only readiness check before any publish actions.
+    for (const headless of [true, false] as const) {
+        try {
+            await withProfilePage(
+                {
+                    profileDir: opts.profileDir,
+                    headless,
+                    url: PUBLISH_URL,
+                    isAuthenticated: (page) => isXhsConsoleReady(wrapPlaywrightPage(page)),
+                    timeoutMs,
+                    launcher: opts.launcher,
+                },
+                async () => undefined,
+            );
+            return {
+                status: 'verified',
                 profileDir: opts.profileDir,
-                headless: true,
-                url: PUBLISH_URL,
-                isAuthenticated: (page) => isXhsConsoleReady(wrapPlaywrightPage(page)),
-                timeoutMs: opts.timeoutMs ?? PREFLIGHT_TIMEOUT_MS,
-                launcher: opts.launcher,
-            },
-            async () => undefined,
-        );
-        return {
-            status: 'verified',
-            profileDir: opts.profileDir,
-            detail: `authenticated ${CHANNEL} creator console observed headlessly via profile ${opts.profileDir} (read-only)`,
-        };
-    } catch (error) {
-        return {
-            status: 'refused',
-            profileDir: opts.profileDir,
-            detail: `headless readiness refused: ${error instanceof Error ? error.message : String(error)}`,
-        };
+                detail: `authenticated ${CHANNEL} creator console observed ${headless ? 'headlessly' : 'via headed fallback'} via profile ${opts.profileDir} (read-only)`,
+            };
+        } catch (error) {
+            if (headless) continue;
+            return {
+                status: 'refused',
+                profileDir: opts.profileDir,
+                detail: `headless and headed readiness refused: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
     }
+    throw new Error('unreachable: session check loop must return or throw');
 }
 
 export class XhsBrowserTransport implements PublishTransport {