@web-auto/webauto 0.1.4 → 0.1.7

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/Phase4MultiTabHarvestBlock.d.ts

@@ -0,0 +1,20 @@
+export interface MultiTabHarvestInput {
+    profile: string;
+    keyword: string;
+    env: string;
+    links: Array<{
+        noteId: string;
+        safeUrl: string;
+        searchUrl?: string;
+    }>;
+    maxCommentsPerNote?: number;
+    unifiedApiUrl?: string;
+}
+export interface MultiTabHarvestOutput {
+    success: boolean;
+    totalNotes: number;
+    totalComments: number;
+    errors: string[];
+}
+export declare function execute(input: MultiTabHarvestInput): Promise<MultiTabHarvestOutput>;
+//# sourceMappingURL=Phase4MultiTabHarvestBlock.d.ts.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/Phase4MultiTabHarvestBlock.js

@@ -0,0 +1,233 @@
+import path from 'node:path';
+import os from 'node:os';
+async function controllerAction(action, payload, apiUrl) {
+    const res = await fetch(`${apiUrl}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action, payload }),
+        signal: AbortSignal.timeout(30000),
+    });
+    const data = await res.json().catch(() => ({}));
+    return data.data || data;
+}
+async function delay(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+async function ensureDir(pathname) {
+    const { mkdir } = await import('node:fs/promises');
+    await mkdir(pathname, { recursive: true });
+}
+async function appendJsonl(filePath, rows) {
+    const { appendFile } = await import('node:fs/promises');
+    const lines = rows.map((row) => JSON.stringify(row)).join('\n') + '\n';
+    await appendFile(filePath, lines, 'utf8');
+}
+function resolveDownloadRoot() {
+    const custom = process.env.WEBAUTO_DOWNLOAD_ROOT || process.env.WEBAUTO_DOWNLOAD_DIR;
+    if (custom && custom.trim())
+        return custom;
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, '.webauto', 'download');
+}
+async function listPages(profile, apiUrl) {
+    const res = await controllerAction('browser:page:list', { profileId: profile }, apiUrl);
+    const pages = res?.pages || res?.data?.pages || [];
+    const activeIndex = res?.activeIndex ?? res?.data?.activeIndex ?? -1;
+    return { pages, activeIndex };
+}
+async function switchToTab(profile, apiUrl, index) {
+    await controllerAction('browser:page:switch', { profileId: profile, index }, apiUrl).catch(() => null);
+    await delay(500);
+    const listRes = await listPages(profile, apiUrl);
+    const activeIndex = listRes.activeIndex;
+    const pages = listRes.pages || [];
+    const activeUrl = pages.find((p) => p.active)?.url || 'N/A';
+    return { activeIndex, activeUrl };
+}
+async function openTabViaWindowOpen(profile, apiUrl) {
+    await controllerAction('browser:page:switch', { profileId: profile, index: 0 }, apiUrl).catch(() => null);
+    await controllerAction('system:shortcut', { app: 'camoufox', shortcut: 'new-tab' }, apiUrl).catch(() => null);
+    await delay(500);
+}
+async function ensureTabPool(profile, apiUrl, requiredTotal = 5) {
+    const existing = await listPages(profile, apiUrl);
+    const currentCount = existing.pages.length;
+    const needed = Math.max(0, requiredTotal - currentCount);
+    if (needed > 0) {
+        for (let i = 0; i < needed; i += 1) {
+            await openTabViaWindowOpen(profile, apiUrl);
+        }
+    }
+    const finalPages = await listPages(profile, apiUrl);
+    return finalPages.pages.slice(1, requiredTotal).map((p) => ({ index: p.index, pageId: p.pageId }));
+}
+async function scrollCommentSection(profile, apiUrl, distance = 600) {
+    const res = await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section',
+        operationId: 'scroll',
+        sessionId: profile,
+        config: { direction: 'down', distance, repeat: 1 },
+    }, apiUrl).catch(() => null);
+    return res?.success !== false;
+}
+async function isCommentEnd(profile, apiUrl) {
+    const res = await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.end_marker',
+        operationId: 'extract',
+        sessionId: profile,
+        config: { max_items: 1, visibleOnly: true },
+    }, apiUrl).catch(() => null);
+    const items = Array.isArray(res?.extracted) ? res.extracted : [];
+    return items.length > 0;
+}
+async function isCommentEmpty(profile, apiUrl) {
+    const res = await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.empty_state',
+        operationId: 'extract',
+        sessionId: profile,
+        config: { max_items: 1, visibleOnly: true },
+    }, apiUrl).catch(() => null);
+    const items = Array.isArray(res?.extracted) ? res.extracted : [];
+    return items.length > 0;
+}
+async function extractComments(profile, apiUrl, limit) {
+    const res = await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.comment_item',
+        operationId: 'extract',
+        sessionId: profile,
+        config: { max_items: limit, visibleOnly: true },
+    }, apiUrl).catch(() => null);
+    return Array.isArray(res?.extracted) ? res.extracted : [];
+}
+async function clickShowMore(profile, apiUrl) {
+    await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.show_more_button',
+        operationId: 'click',
+        sessionId: profile,
+        config: { scroll_to_view: true, wait_after: 500, visibleOnly: true },
+    }, apiUrl).catch(() => null);
+}
+export async function execute(input) {
+    const { profile, keyword, env, links, maxCommentsPerNote = 50, unifiedApiUrl = 'http://127.0.0.1:7701', } = input;
+    const downloadRoot = resolveDownloadRoot();
+    console.log(`[Phase4MultiTab] 开始多Tab轮转采集，总链接: ${links.length}`);
+    const tabPool = await ensureTabPool(profile, unifiedApiUrl, 5);
+    const workers = [
+        { slot: 1, tabIndex: tabPool[0]?.index ?? 1, currentLinkIndex: 0, commentsThisRound: 0, totalComments: 0 },
+        { slot: 2, tabIndex: tabPool[1]?.index ?? 2, currentLinkIndex: 1, commentsThisRound: 0, totalComments: 0 },
+        { slot: 3, tabIndex: tabPool[2]?.index ?? 3, currentLinkIndex: 2, commentsThisRound: 0, totalComments: 0 },
+        { slot: 4, tabIndex: tabPool[3]?.index ?? 4, currentLinkIndex: 3, commentsThisRound: 0, totalComments: 0 },
+    ];
+    const linkStates = links.map((l, i) => ({
+        ...l,
+        index: i,
+        done: false,
+        totalComments: 0,
+    }));
+    let completedLinks = 0;
+    const errors = [];
+    let round = 0;
+    const maxRounds = links.length * 2;
+    while (completedLinks < links.length && round < maxRounds) {
+        round++;
+        const worker = workers[(round - 1) % workers.length];
+        let linkToProcess = linkStates.find(l => !l.done && l.index >= worker.currentLinkIndex);
+        if (!linkToProcess) {
+            linkToProcess = linkStates.find(l => !l.done);
+        }
+        if (!linkToProcess) {
+            console.log(`[Phase4MultiTab] 所有链接已完成`);
+            break;
+        }
+        worker.currentLinkIndex = linkToProcess.index;
+        console.log(`\n[Round ${round}] slot-${worker.slot}(tab-${worker.tabIndex}) -> note ${linkToProcess.noteId}`);
+        try {
+            const activeInfo = await switchToTab(profile, unifiedApiUrl, worker.tabIndex);
+            console.log(`[Phase4MultiTab] activeIndex=${activeInfo.activeIndex} url=${String(activeInfo.activeUrl).slice(0, 60)}`);
+            const navRes = await controllerAction('browser:goto', {
+                profile,
+                url: linkToProcess.safeUrl,
+            }, unifiedApiUrl);
+            const navOk = navRes?.success === true || navRes?.result?.ok === true || navRes?.ok === true;
+            if (!navOk) {
+                console.log(`[Phase4MultiTab] navRes=${JSON.stringify(navRes)}`);
+                throw new Error(`导航失败: ${navRes?.error || JSON.stringify(navRes)}`);
+            }
+            await delay(2000);
+            await controllerAction('container:operation', {
+                containerId: 'xiaohongshu_detail.comment_button',
+                operationId: 'highlight',
+                sessionId: profile,
+            }, unifiedApiUrl).catch(() => null);
+            await controllerAction('container:operation', {
+                containerId: 'xiaohongshu_detail.comment_button',
+                operationId: 'click',
+                sessionId: profile,
+                config: { useSystemMouse: true, visibleOnly: true },
+            }, unifiedApiUrl).catch(() => null);
+            await delay(1200);
+            let collected = 0;
+            let scrollAttempts = 0;
+            const maxScrolls = Infinity;
+            await clickShowMore(profile, unifiedApiUrl);
+            await delay(800);
+            while (collected < maxCommentsPerNote && scrollAttempts < maxScrolls) {
+                const items = await extractComments(profile, unifiedApiUrl, maxCommentsPerNote - collected);
+                if (items.length === 0) {
+                    const empty = await isCommentEmpty(profile, unifiedApiUrl);
+                    if (empty) {
+                        console.log(`[Phase4MultiTab] slot-${worker.slot} 评论区空`);
+                        break;
+                    }
+                    await scrollCommentSection(profile, unifiedApiUrl, 650);
+                    await delay(900);
+                    scrollAttempts++;
+                    continue;
+                }
+                const noteDir = path.join(downloadRoot, 'xiaohongshu', env, keyword, linkToProcess.noteId);
+                await ensureDir(noteDir);
+                const payload = items.map((item) => ({
+                    ...item,
+                    noteId: linkToProcess.noteId,
+                    ts: new Date().toISOString(),
+                }));
+                await appendJsonl(path.join(noteDir, 'comments.jsonl'), payload);
+                collected += items.length;
+                scrollAttempts = 0;
+                const isEnd = await isCommentEnd(profile, unifiedApiUrl);
+                if (isEnd) {
+                    console.log(`[Phase4MultiTab] slot-${worker.slot} 评论到底`);
+                    break;
+                }
+                await clickShowMore(profile, unifiedApiUrl);
+                await delay(600);
+                await scrollCommentSection(profile, unifiedApiUrl, 650);
+                await delay(900);
+            }
+            worker.commentsThisRound = collected;
+            worker.totalComments += collected;
+            linkToProcess.totalComments += collected;
+            linkToProcess.done = true;
+            completedLinks++;
+            console.log(`[Phase4MultiTab] slot-${worker.slot} ✅ 采集 ${collected} 条，该帖累计 ${linkToProcess.totalComments} 条`);
+            console.log(`[Phase4MultiTab] 进度: ${completedLinks}/${links.length} 帖子完成`);
+        }
+        catch (err) {
+            const errorMsg = err?.message || String(err);
+            console.error(`[Phase4MultiTab] slot-${worker.slot} ❌ 失败: ${errorMsg}`);
+            errors.push(`${linkToProcess.noteId}: ${errorMsg}`);
+            linkToProcess.done = true;
+            completedLinks++;
+        }
+        await delay(800);
+    }
+    const totalComments = linkStates.reduce((sum, l) => sum + l.totalComments, 0);
+    console.log(`\n[Phase4MultiTab] 完成: ${completedLinks} 帖子, ${totalComments} 条评论`);
+    return {
+        success: true,
+        totalNotes: completedLinks,
+        totalComments,
+        errors,
+    };
+}
+//# sourceMappingURL=Phase4MultiTabHarvestBlock.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/ReplyInteractBlock.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Block: ReplyInteract（开发态：模拟回复）
+ *
+ * 职责：
+ * 1) 在指定评论上点击“回复”
+ * 2) 定位回复输入框并输入内容（系统级键盘）
+ * 3) 截图留证（包含高亮与 DEV 叠加文案）
+ *
+ * 约束：
+ * - 点击必须走坐标点击（mouse:click），禁止 DOM click
+ * - 不提交（不发送真正回复）
+ */
+export interface ReplyInteractInput {
+    sessionId: string;
+    noteId: string;
+    commentVisibleIndex: number;
+    replyText: string;
+    dryRun?: boolean;
+    unifiedApiUrl?: string;
+    env?: string;
+    keyword?: string;
+    dev?: boolean;
+}
+export interface ReplyInteractOutput {
+    success: boolean;
+    noteId: string;
+    typed: boolean;
+    evidence?: {
+        screenshot?: string | null;
+    };
+    debug?: {
+        replyButtonRect?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        replyInputRect?: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    error?: string;
+}
+export declare function execute(input: ReplyInteractInput): Promise<ReplyInteractOutput>;
+//# sourceMappingURL=ReplyInteractBlock.d.ts.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/ReplyInteractBlock.js

@@ -0,0 +1,291 @@
+/**
+ * Block: ReplyInteract（开发态：模拟回复）
+ *
+ * 职责：
+ * 1) 在指定评论上点击“回复”
+ * 2) 定位回复输入框并输入内容（系统级键盘）
+ * 3) 截图留证（包含高亮与 DEV 叠加文案）
+ *
+ * 约束：
+ * - 点击必须走坐标点击（mouse:click），禁止 DOM click
+ * - 不提交（不发送真正回复）
+ */
+import path from 'node:path';
+import { controllerAction, delay } from '../utils/controllerAction.js';
+import { resolveDownloadRoot, savePngBase64, takeScreenshotBase64 } from './helpers/evidence.js';
+async function findReplyButtonTarget(sessionId, apiUrl, commentVisibleIndex) {
+    const res = await controllerAction('browser:execute', {
+        profile: sessionId,
+        script: `(() => {
+        const idx = ${JSON.stringify(commentVisibleIndex)};
+        const isVisible = (el) => {
+          const r = el.getBoundingClientRect();
+          return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < window.innerHeight && r.right > 0 && r.left < window.innerWidth;
+        };
+        const items = Array.from(document.querySelectorAll('.comment-item')).filter(isVisible);
+        const root = items[idx];
+        if (!root) return { ok: false, reason: 'comment-not-found', total: items.length };
+
+        const textEq = (el, s) => (el && (el.textContent || '').replace(/\\s+/g,' ').trim() === s);
+        const candidates = Array.from(root.querySelectorAll('span.count,button,a,span,div'));
+        const raw = candidates.find(el => textEq(el, '回复')) || null;
+        if (!raw) return { ok: false, reason: 'reply-button-not-found' };
+
+        const target = raw.closest && (raw.closest('button,a,[role=\"button\"]') || raw) || raw;
+        const r = target.getBoundingClientRect();
+        if (!r || !r.width || !r.height) return { ok: false, reason: 'reply-rect-empty' };
+
+        const x1 = Math.max(0, r.left);
+        const y1 = Math.max(0, r.top);
+        const x2 = Math.min(window.innerWidth, r.right);
+        const y2 = Math.min(window.innerHeight, r.bottom);
+        const mx = Math.round((x1 + x2) / 2);
+        const my = Math.round((y1 + y2) / 2);
+        const pad = 10;
+        const points = [
+          { x: mx, y: my },
+          { x: Math.round(x1 + pad), y: my },
+          { x: Math.round(x2 - pad), y: my },
+          { x: mx, y: Math.round(y1 + pad) },
+          { x: mx, y: Math.round(y2 - pad) },
+        ].filter(p => Number.isFinite(p.x) && Number.isFinite(p.y) && p.x >= 0 && p.y >= 0 && p.x <= window.innerWidth && p.y <= window.innerHeight);
+
+        let clickPoint = points[0] || { x: mx, y: my };
+        for (const p of points) {
+          const hit = document.elementFromPoint(p.x, p.y);
+          if (hit && (hit === target || target.contains(hit))) { clickPoint = p; break; }
+        }
+
+        return {
+          ok: true,
+          rect: { x: Math.round(r.left), y: Math.round(r.top), width: Math.round(r.width), height: Math.round(r.height) },
+          clickPoint,
+        };
+      })()`,
+    }, apiUrl);
+    const payload = res?.result || res?.data?.result || res;
+    return payload;
+}
+async function findReplyInputTarget(sessionId, apiUrl) {
+    const res = await controllerAction('browser:execute', {
+        profile: sessionId,
+        script: `(() => {
+        const isVisible = (el) => {
+          if (!el || !el.getBoundingClientRect) return false;
+          const r = el.getBoundingClientRect();
+          return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < window.innerHeight && r.right > 0 && r.left < window.innerWidth;
+        };
+        const score = (el) => {
+          const ph = (el.getAttribute && (el.getAttribute('placeholder') || el.getAttribute('aria-label') || '')) || '';
+          const cls = (el.className || '').toString();
+          const hint = (ph + ' ' + cls).replace(/\\s+/g,' ').trim();
+          let s = 0;
+          if (hint.includes('回复')) s += 4;
+          if (hint.includes('评论') || hint.includes('说点什么') || hint.includes('说说')) s += 2;
+          if (cls.includes('reply')) s += 3;
+          if (cls.includes('comment')) s += 1;
+          return s;
+        };
+
+        const active = document.activeElement;
+        const isInputLike = (el) => el && (el.tagName === 'TEXTAREA' || (el.tagName === 'INPUT') || (el.isContentEditable === true));
+        if (isInputLike(active) && isVisible(active)) {
+          const r = active.getBoundingClientRect();
+          const mx = Math.round((r.left + r.right) / 2);
+          const my = Math.round((r.top + r.bottom) / 2);
+          return { ok: true, rect: { x: Math.round(r.left), y: Math.round(r.top), width: Math.round(r.width), height: Math.round(r.height) }, clickPoint: { x: mx, y: my } };
+        }
+
+        const all = Array.from(document.querySelectorAll('textarea, input[type=\"text\"], input:not([type]), [contenteditable=\"true\"], [contenteditable=\"plaintext-only\"]'))
+          .filter(isVisible);
+        if (!all.length) return { ok: false, reason: 'no-visible-input' };
+
+        const best = all
+          .map((el) => ({ el, s: score(el) }))
+          .sort((a,b) => b.s - a.s)[0];
+        const el = best.el;
+        const r = el.getBoundingClientRect();
+        const mx = Math.round((r.left + r.right) / 2);
+        const my = Math.round((r.top + r.bottom) / 2);
+        return { ok: true, rect: { x: Math.round(r.left), y: Math.round(r.top), width: Math.round(r.width), height: Math.round(r.height) }, clickPoint: { x: mx, y: my } };
+      })()`,
+    }, apiUrl);
+    const payload = res?.result || res?.data?.result || res;
+    return payload;
+}
+async function drawOverlay(sessionId, apiUrl, opts) {
+    const ttlMs = typeof opts.ttlMs === 'number' ? Math.max(600, Math.min(15000, Math.floor(opts.ttlMs))) : 4000;
+    await controllerAction('browser:execute', {
+        profile: sessionId,
+        script: `(() => {
+        const id = ${JSON.stringify(opts.id)};
+        const rect = ${JSON.stringify(opts.rect || null)};
+        const color = ${JSON.stringify(opts.color)};
+        const label = ${JSON.stringify(opts.label || '')};
+        const ttl = ${JSON.stringify(ttlMs)};
+
+        const ensure = (elId, baseStyle) => {
+          let el = document.getElementById(elId);
+          if (!el) {
+            el = document.createElement('div');
+            el.id = elId;
+            document.body.appendChild(el);
+          }
+          Object.assign(el.style, baseStyle);
+          return el;
+        };
+
+        if (rect) {
+          ensure(id, {
+            position: 'fixed',
+            left: rect.x + 'px',
+            top: rect.y + 'px',
+            width: rect.width + 'px',
+            height: rect.height + 'px',
+            border: '3px solid ' + color,
+            boxSizing: 'border-box',
+            zIndex: '2147483647',
+            pointerEvents: 'none',
+          });
+        }
+
+        if (label) {
+          ensure(id + '-label', {
+            position: 'fixed',
+            left: '12px',
+            top: '12px',
+            maxWidth: '70vw',
+            padding: '8px 10px',
+            background: 'rgba(0,0,0,0.75)',
+            color: '#fff',
+            fontSize: '12px',
+            lineHeight: '1.3',
+            borderRadius: '8px',
+            zIndex: '2147483647',
+            pointerEvents: 'none',
+            whiteSpace: 'pre-wrap',
+          }).textContent = label;
+        }
+
+        setTimeout(() => {
+          try {
+            const a = document.getElementById(id);
+            if (a && a.parentElement) a.parentElement.removeChild(a);
+            const b = document.getElementById(id + '-label');
+            if (b && b.parentElement) b.parentElement.removeChild(b);
+          } catch {}
+        }, ttl);
+
+        return true;
+      })()`,
+    }, apiUrl).catch(() => null);
+}
+async function verifyTyped(sessionId, apiUrl, expected) {
+    const res = await controllerAction('browser:execute', {
+        profile: sessionId,
+        script: `(() => {
+        const exp = ${JSON.stringify(expected)};
+        const el = document.activeElement;
+        if (!el) return { ok: false, value: '' };
+        let v = '';
+        if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) v = el.value || '';
+        else if (el instanceof HTMLElement && el.isContentEditable) v = (el.textContent || '');
+        v = (v || '').replace(/\\s+/g,' ').trim();
+        return { ok: true, value: v, contains: exp ? v.includes(exp) : false };
+      })()`,
+    }, apiUrl).catch(() => null);
+    const payload = res?.result || res?.data?.result || res;
+    return Boolean(payload?.contains);
+}
+export async function execute(input) {
+    const { sessionId, noteId, commentVisibleIndex, replyText, dryRun = false, unifiedApiUrl = 'http://127.0.0.1:7701', env = 'debug', keyword = 'unknown', dev = true, } = input;
+    let screenshot = null;
+    let replyButtonRect = undefined;
+    let replyInputRect = undefined;
+    try {
+        const btn = await findReplyButtonTarget(sessionId, unifiedApiUrl, commentVisibleIndex);
+        if (!btn.ok || !btn.clickPoint || !btn.rect) {
+            throw new Error(`reply button not found: ${btn.reason || 'unknown'}`);
+        }
+        replyButtonRect = btn.rect;
+        await drawOverlay(sessionId, unifiedApiUrl, {
+            id: 'webauto-reply-button-rect',
+            rect: btn.rect,
+            color: '#00e5ff',
+            ttlMs: 6000,
+        });
+        await delay(350);
+        if (!dryRun) {
+            // ✅ 坐标点击（系统点击）
+            await controllerAction('mouse:click', { profileId: sessionId, x: Math.round(btn.clickPoint.x), y: Math.round(btn.clickPoint.y) }, unifiedApiUrl);
+            await delay(700);
+        }
+        else {
+            await delay(450);
+        }
+        const inputTarget = await findReplyInputTarget(sessionId, unifiedApiUrl);
+        if (inputTarget.ok && inputTarget.clickPoint && inputTarget.rect) {
+            replyInputRect = inputTarget.rect;
+            await drawOverlay(sessionId, unifiedApiUrl, {
+                id: 'webauto-reply-input-rect',
+                rect: inputTarget.rect,
+                color: '#ff00ff',
+                ttlMs: 6000,
+            });
+            await delay(250);
+            if (!dryRun) {
+                // ✅ 坐标点击聚焦输入框
+                await controllerAction('mouse:click', { profileId: sessionId, x: Math.round(inputTarget.clickPoint.x), y: Math.round(inputTarget.clickPoint.y) }, unifiedApiUrl);
+                await delay(220);
+                // 清空（可选）：dev 模式仍执行，避免误拼接
+                const isMac = process.platform === 'darwin';
+                await controllerAction('keyboard:press', { profileId: sessionId, key: isMac ? 'Meta+A' : 'Control+A' }, unifiedApiUrl).catch(() => { });
+                await delay(80);
+                await controllerAction('keyboard:press', { profileId: sessionId, key: 'Backspace' }, unifiedApiUrl).catch(() => { });
+                await delay(120);
+                // ✅ 系统级输入（不提交）
+                await controllerAction('keyboard:type', { profileId: sessionId, text: String(replyText || ''), delay: 90, submit: false }, unifiedApiUrl);
+                await delay(260);
+            }
+            else {
+                await delay(180);
+            }
+        }
+        const typed = !dryRun && replyInputRect
+            ? await verifyTyped(sessionId, unifiedApiUrl, String(replyText || '').slice(0, 6))
+            : false;
+        if (dev || dryRun) {
+            await drawOverlay(sessionId, unifiedApiUrl, {
+                id: 'webauto-dev-reply-label',
+                color: '#00ff00',
+                label: `[${dryRun ? 'DRYRUN' : 'DEV'}] note=${noteId} commentIdx=${commentVisibleIndex}\nreply: ${String(replyText || '').slice(0, 80)}`,
+                ttlMs: 9000,
+            });
+            await delay(180);
+        }
+        const base64 = await takeScreenshotBase64(sessionId, unifiedApiUrl);
+        if (base64) {
+            const outDir = path.join(resolveDownloadRoot(), 'xiaohongshu', env, keyword, 'smart-reply', noteId);
+            const name = `reply-dev-${String(commentVisibleIndex).padStart(3, '0')}-${Date.now()}.png`;
+            screenshot = await savePngBase64(base64, path.join(outDir, name));
+        }
+        return {
+            success: true,
+            noteId,
+            typed,
+            evidence: { screenshot },
+            debug: { replyButtonRect, replyInputRect },
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            noteId,
+            typed: false,
+            evidence: { screenshot },
+            debug: { replyButtonRect, replyInputRect },
+            error: e?.message || String(e),
+        };
+    }
+}
+//# sourceMappingURL=ReplyInteractBlock.js.map

package/dist/modules/xiaohongshu/app/src/xiaohongshu/app/src/blocks/XhsDiscoverFallbackBlock.d.ts

@@ -0,0 +1,23 @@
+/**
+ * XHS Discover Fallback Block
+ *
+ * 独立的回退 Block：当出现 shell-page（URL=/explore/<id> 但 DOM=搜索结果）时，
+ * 通过点击「发现」按钮重置状态，然后重新搜索以获取正确的 /search_result URL。
+ *
+ * 约束：全系统级操作（container + keyboard/mouse），禁止 goto/refresh/url 拼接。
+ */
+export interface DiscoverFallbackInput {
+    keyword: string;
+    profile?: string;
+    unifiedApiUrl?: string;
+    env?: string;
+}
+export interface DiscoverFallbackOutput {
+    success: boolean;
+    finalUrl: string;
+    finalCheckpoint: string;
+    screenshotPath?: string;
+    domDumpPath?: string;
+}
+export declare function execute(input: DiscoverFallbackInput): Promise<DiscoverFallbackOutput>;
+//# sourceMappingURL=XhsDiscoverFallbackBlock.d.ts.map