@gobing-ai/knowledge-kit 0.1.12 → 0.1.14

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

@@ -57,8 +57,15 @@ const ARTICLE_LAYOUT = ['button:has-text("一键排版")', 'div.ailayout-btn_wrp
 const PODCAST_OPEN = ['text=上传音频', 'button:has-text("上传音频")'];
 const PODCAST_MODAL = ['div.creator-modal-sty', '.d-modal.d-modal-centered', '.d-modal'];
 const PODCAST_AUDIO_INPUT = ['input[type="file"][accept*=".mp3"]', 'input[type="file"][accept*=".wav"]'];
-const PODCAST_COVER_INPUT = ['input[type="file"][accept*=".jpg"]', 'input[type="file"][accept*=".png"]'];
 const PODCAST_MODAL_ADVANCE = ['去发布'];
+/* Measured post-attach flow (2026-11-06 headless probe, 10-min mp3 + 1:1 png): a raw
+ * input.files assignment registers the AUDIO (`上传成功` appears) but the COVER card never
+ * advances and `去发布` stays `disabled` — only clicking the cover card and handing the file to
+ * the native file chooser the site opens takes both. `去发布` is then just the ADVANCE control: the
+ * next page is the full podcast editor carrying the closed-shadow bar (`暂存离开`@left, `发布`@right),
+ * so a draft run may click it too — it does not publish on its own. */
+const PODCAST_COVER_ZONE = '.d-modal div:has-text("设置封面")';
+const PODCAST_UPLOAD_ACK = '上传成功';
 
 /**
  * The `暂存离开` labels, newest first: XHS renamed the control, and the older labels stay as
@@ -401,32 +408,85 @@ async function isPodcastModalOpen(page: XhsPage): Promise<boolean> {
         .catch(() => false);
 }
 
+async function clickPodcastModalDomFallback(page: XhsPage): Promise<string> {
+    const res = await page
+        .evaluate(
+            `(() => {
+                const modals = Array.from(document.querySelectorAll('.d-modal, div.creator-modal-sty'));
+                const buttons = Array.from(document.querySelectorAll('.d-modal button, div.creator-modal-sty button, .d-modal-mask button'));
+                const confirmLabels = ['确定', '完成', '确认', '保存'];
+                const cropBtn = buttons.find((b) => {
+                    const t = (b.textContent || '').trim();
+                    return confirmLabels.includes(t) && !b.classList.contains('cancel-btn') && !b.dataset.kkClicked;
+                }) || (modals.length > 1 ? Array.from(modals[modals.length - 1].querySelectorAll('button')).find((b) => !b.classList.contains('cancel-btn') && b.classList.contains('bg-red') && !(b.textContent || '').includes('去发布') && !b.dataset.kkClicked) : null);
+                if (cropBtn && typeof cropBtn.click === 'function') {
+                    cropBtn.dataset.kkClicked = '1';
+                    cropBtn.click();
+                    return JSON.stringify({ modals: modals.length, clickedCrop: true, clickedAdvance: false });
+                }
+                const advBtns = buttons.filter((b) => (b.textContent || '').includes('去发布') && !b.hasAttribute('disabled') && b.getAttribute('aria-disabled') !== 'true');
+                const adv = advBtns[advBtns.length - 1];
+                let clickedAdvance = false;
+                if (adv && !adv.dataset.kkClicked && typeof adv.click === 'function') {
+                    adv.dataset.kkClicked = '1';
+                    adv.click();
+                    clickedAdvance = true;
+                }
+                return JSON.stringify({
+                    modals: modals.length,
+                    clickedCrop: false,
+                    clickedAdvance,
+                    buttons: buttons.map((b) => ({ text: (b.textContent || '').trim(), cls: b.className, disabled: b.hasAttribute('disabled') })),
+                });
+            })()`,
+        )
+        .catch(() => '');
+    return typeof res === 'string' ? res : '';
+}
+
 /**
- * Leave the 发播客 modal. The recorded advance control is `去发布`, which is publish-adjacent, so a
-draft run never clicks it: it waits for the platform to move on by itself and fails loud naming the
-control it refused to click. Only an explicit `publishStatus: 'public'` may click it.
- *
- * 0236 R3 (deferred, operator decision 2026-10-09): whether the modal offers a save path OTHER than
- * `去发布` once both files are attached was never measured (`.spur/run/discovery/` holds only the
- * modal open), and an attended walk under ADR-025 is what would measure it. So no draft-save selector
- * is invented here: the run stops before the publish-adjacent control and says so, which is the
- * failure the 0236 result carries (a `ok:false` entry that never fails the visit).
+ * Leave the 发播客 modal. 0236 R3 is now measured (2026-11-06 headless probe): the modal's only
+ * controls are `取消` and the light-DOM `去发布`, and `去发布` does not publish — it opens the full
+ * podcast editor whose action bar is the same closed-shadow `暂存离开`/`发布` pair every other mode
+ * uses, so BOTH publish statuses take the same advance click and the draft decision moves to the
+ * editor's action bar (MODE_ACTION_PATHS['发播客'] already routes `shadow`). Draft saving
+ * waits for the modal to close by itself first — only that timed-dead path names what it saw.
  */
 async function leavePodcastModal(deps: ModeRunDeps): Promise<void> {
     const closed = () => isPodcastModalOpen(deps.page).then((open) => !open);
-    if (await waitUntil(closed, deps.stepTimeoutMs)) return;
-    if (deps.publishStatus === 'public') {
+    if (!(await isPodcastModalOpen(deps.page))) return;
+    let usedFallback = false;
+    let lastDiag = '';
+    try {
         const advance = await clickLightControl(
             deps.page,
             PODCAST_MODAL_ADVANCE,
-            deps.stepTimeoutMs,
+            Math.min(deps.stepTimeoutMs, 2_500),
             'podcast modal advance',
         );
-        if (!advance.ok) throw new Error(advance.error);
-        if (await waitUntil(closed, deps.stepTimeoutMs)) return;
+        if (!advance.ok) {
+            lastDiag = await clickPodcastModalDomFallback(deps.page);
+            if (!lastDiag.startsWith('{')) throw new Error(advance.error);
+            usedFallback = true;
+        }
+    } catch {
+        lastDiag = await clickPodcastModalDomFallback(deps.page);
+        usedFallback = true;
+    }
+    if (
+        await waitUntil(async () => {
+            if (await closed()) return true;
+            if (usedFallback) {
+                lastDiag = await clickPodcastModalDomFallback(deps.page);
+            }
+            return false;
+        }, deps.stepTimeoutMs)
+    ) {
+        return;
     }
+    const diagSuffix = lastDiag ? ` [modal=${lastDiag}]` : '';
     throw new Error(
-        `podcast modal: the 发播客 modal was still open ${deps.stepTimeoutMs}ms after the audio and cover were attached; its post-attach save path has never been measured (task 0236 R3 — the attended walk is still pending) and the only recorded advance control is '${PODCAST_MODAL_ADVANCE[0]}', which a draft run does not click (it is publish-adjacent)`,
+        `podcast modal: the 发播客 modal stayed open ${deps.stepTimeoutMs}ms after the advance click; the measured 2026-11-06 flow moves to the podcast editor page with the closed-shadow '${DRAFT_LABELS[0]}' bar, so a fast re-measure with a fresh probe is the next step, not a retry${diagSuffix}`,
     );
 }
 
@@ -445,16 +505,127 @@ async function composePodcast(
         deps.stepTimeoutMs,
     );
     await uploadFile(asPlaywrightPage(deps.page), audioInput, input.audio, { timeoutMs: deps.stepTimeoutMs });
-    const coverInput = await findAttachedSelector(
-        deps.page,
-        PODCAST_COVER_INPUT,
-        'podcast cover input',
-        deps.stepTimeoutMs,
-    );
-    await uploadFile(asPlaywrightPage(deps.page), coverInput, input.cover, { timeoutMs: deps.stepTimeoutMs });
+    // The audio card's acknowledgement is the registration signal: no ack in the window means the
+    // assignment did not take, and the cover chooser would then find `去发布` disabled and stall.
+    const ack = await waitUntil(async () => {
+        try {
+            return (await deps.page.locator(`text=${PODCAST_UPLOAD_ACK}`).count()) > 0;
+        } catch {
+            return false;
+        }
+    }, deps.stepTimeoutMs);
+    if (!ack) {
+        throw new Error(
+            `podcast modal: the audio card never showed '${PODCAST_UPLOAD_ACK}' within ${deps.stepTimeoutMs}ms of the file assignment; mimic-file upload of ${input.audio.split('/').pop()} did not register`,
+        );
+    }
+    await uploadPodcastCover(deps, input.cover);
+    await podcastAdvanceReady(deps);
     await leavePodcastModal(deps);
 }
 
+async function uploadPodcastCover(deps: ModeRunDeps, cover: string): Promise<void> {
+    const zone = deps.page.locator(PODCAST_COVER_ZONE).first();
+    const box = await zone.boundingBox().catch(() => null);
+    if (!box) {
+        throw new Error(`podcast modal: the cover card ('${PODCAST_COVER_ZONE}') has no bounding box to click`);
+    }
+    if (!deps.page.mouse) {
+        throw new Error('podcast modal: the page seam does not expose a raw mouse for the cover-card coordinate click');
+    }
+    const chooser = deps.page.waitForEvent?.('filechooser', { timeout: 8_000 }).catch(() => null) as Promise<
+        unknown | null
+    >;
+    await deps.page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+    const pending = Symbol('pending');
+    const quick = await Promise.race([
+        chooser,
+        new Promise<typeof pending>((resolve) => setTimeout(() => resolve(pending), 400)),
+    ]);
+    let diag = '';
+    if (quick === pending) {
+        const fallback = await deps.page
+            .evaluate(
+                `(() => {
+                    const modal = document.querySelector('.d-modal') || document.body;
+                    const inputs = Array.from(modal.querySelectorAll('input[type="file"]'));
+                    const coverInput = inputs.find((i) => !String(i.getAttribute('accept') || '').includes('.mp3'));
+                    const all = Array.from(modal.querySelectorAll('*')).filter((el) => (el.textContent || '').includes('设置封面'));
+                    const leaf = all[all.length - 1];
+                    let card = leaf;
+                    while (card && card.parentElement && card.parentElement !== modal) {
+                        const pt = card.parentElement.textContent || '';
+                        if (pt.includes('上传成功') || pt.includes('点击上传') || pt.includes('去发布')) break;
+                        card = card.parentElement;
+                    }
+                    let clickedInput = false;
+                    if (coverInput && typeof coverInput.click === 'function') {
+                        coverInput.click();
+                        clickedInput = true;
+                    } else {
+                        if (card && typeof card.click === 'function') card.click();
+                        if (leaf && typeof leaf.click === 'function') leaf.click();
+                    }
+                    const rect = card ? card.getBoundingClientRect() : null;
+                    return JSON.stringify({
+                        clickedInput,
+                        x: rect ? Math.round(rect.left + rect.width / 2) : null,
+                        y: rect ? Math.round(rect.top + rect.height * 0.35) : null,
+                        inputs: inputs.map((i) => ({ accept: i.getAttribute('accept'), cls: i.className })),
+                        cardTag: card ? card.tagName + '.' + String(card.className) : null,
+                        cardRect: rect ? [Math.round(rect.left), Math.round(rect.top), Math.round(rect.width), Math.round(rect.height)] : null,
+                    });
+                })()`,
+            )
+            .catch(() => '');
+        if (typeof fallback === 'string' && fallback.startsWith('{')) {
+            diag = ` [modal=${fallback}]`;
+            try {
+                const parsed = JSON.parse(fallback) as {
+                    clickedInput?: boolean;
+                    x?: number | null;
+                    y?: number | null;
+                };
+                if (!parsed.clickedInput && typeof parsed.x === 'number' && typeof parsed.y === 'number') {
+                    await deps.page.mouse.click(parsed.x, parsed.y);
+                }
+            } catch {
+                // ignore parse errors on diagnostic payload
+            }
+        }
+    }
+    const opened = quick === pending ? await chooser : quick;
+    if (!opened) {
+        throw new Error(
+            `podcast modal: clicking the cover card did not open a native file chooser within 8000ms${diag}`,
+        );
+    }
+    await (opened as { setFiles(path: string): Promise<void> }).setFiles(cover);
+}
+
+/** Wait until the advance control is enabled — `去发布` stays `disabled` until BOTH cards took. */
+async function podcastAdvanceReady(deps: ModeRunDeps): Promise<void> {
+    if (deps.publishStatus !== 'draft') {
+        return;
+    }
+    const enabled = await waitUntil(async () => {
+        try {
+            if ((await deps.page.locator('button:has-text("去发布")').count()) === 0) return false;
+            const disabled = await deps.page
+                .locator('button:has-text("去发布")[disabled], button:has-text("去发布")[aria-disabled="true"]')
+                .count();
+            return disabled === 0;
+        } catch {
+            return false;
+        }
+    }, deps.stepTimeoutMs);
+    if (!enabled) {
+        throw new Error(
+            `podcast modal: '${PODCAST_MODAL_ADVANCE[0]}' stayed disabled — the cards were not both accepted; check the audio ack '${PODCAST_UPLOAD_ACK}' and retry with the cover chooser path`,
+        );
+    }
+}
+
 /** Compose the requested mode's post. Exhaustive over {@link ModeInput}. */
 async function compose(input: ModeInput, deps: ModeRunDeps): Promise<void> {
     switch (input.operation) {

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

@@ -58,6 +58,8 @@ export interface XhsLocator {
      */
     type?(text: string, options?: { timeout?: number; delay?: number }): Promise<void>;
     textContent?(): Promise<string>;
+    /** The card's click box — the native-chooser path clicks at its centre. */
+    boundingBox(): Promise<{ x: number; y: number; width: number; height: number } | null>;
 }
 
 /** Structural subset of the Playwright page the script driver uses. */
@@ -74,6 +76,10 @@ export interface XhsPage {
     countOnScreen(selector: string): Promise<number>;
     /** Click the first on-screen match — the console renders the tabs 3×. */
     clickInViewport?(selector: string): Promise<boolean>;
+    /** The 发播客 cover card resolves its file through the site's native file chooser. */
+    waitForEvent?(event: string, options?: { timeout?: number }): Promise<unknown | null>;
+    /** Raw mouse press (the tab-bar clone debris needs coordinate clicks). */
+    mouse?: { click(x: number, y: number): Promise<void> };
     /** Resolve a labelled control inside a closed shadow root. */
     findShadowControl?(labels: readonly string[]): Promise<ShadowControl | null>;
     /** Click at viewport coordinates. */
@@ -154,6 +160,7 @@ export function wrapPlaywrightPage(raw: unknown, shadow?: ShadowProbe): XhsPage
         viewportSize?(): { width: number; height: number } | null;
         evaluate(expression: string): Promise<unknown>;
         mouse: { click(x: number, y: number): Promise<void> };
+        waitForEvent?: (event: string, options?: Record<string, unknown>) => Promise<unknown>;
     };
 
     /**
@@ -202,12 +209,22 @@ export function wrapPlaywrightPage(raw: unknown, shadow?: ShadowProbe): XhsPage
                     isVisible(o?: Record<string, unknown>): Promise<boolean>;
                     fill(t: string, o?: Record<string, unknown>): Promise<void>;
                     click(o?: Record<string, unknown>): Promise<void>;
+                    boundingBox?(): Promise<{
+                        x: number;
+                        y: number;
+                        width: number;
+                        height: number;
+                    } | null>;
                 };
                 return {
                     count: () => loc.count(),
                     isVisible: (options) => loc.isVisible(options),
                     fill: (text, options) => loc.fill(text, options),
                     click: (options) => loc.click(options),
+                    // A `:has-text(...)` selector matches every ancestor `div` in pre-order before
+                    // the leaf card itself; the last on-screen match is the innermost element.
+                    boundingBox: async () =>
+                        (await onScreen(selector)).at(-1)?.box ?? (await loc.boundingBox?.()) ?? null,
                     type: (text, options) =>
                         (
                             loc as unknown as {
@@ -232,6 +249,15 @@ export function wrapPlaywrightPage(raw: unknown, shadow?: ShadowProbe): XhsPage
         },
         findShadowControl: async (labels) => (shadow ? shadow.findControl(labels) : null),
         clickAt: (x, y) => pw.mouse.click(x, y),
+        waitForEvent: (event, options) => {
+            if (typeof pw.waitForEvent !== 'function') {
+                return Promise.reject(new Error(`the page seam does not expose a '${event}' event source`));
+            }
+            return pw.waitForEvent(event, options) as Promise<unknown>;
+        },
+        mouse: {
+            click: (x, y) => pw.mouse.click(x, y),
+        },
     };
 }